package com.wicket.okrapp.biz.service.impl;

import cn.hutool.core.bean.BeanUtil;
import com.wicket.okrapp.biz.service.dto.common.PlanningExportDetailDto;
import com.wicket.okrapp.biz.service.dto.common.TargetContentDto;
import com.wicket.okrapp.biz.service.dto.req.*;
import com.wicket.okrapp.biz.service.dto.res.*;
import com.wicket.okrapp.common.exception.BizException;
import com.wicket.okrapp.common.util.CommonFunctionHelper;
import com.wicket.okrapp.common.util.RedisUtil;
import java.util.List;
import java.util.stream.Collectors;
import javax.annotation.Resource;

import com.wicket.okrcalc.integration.dto.StandardDataDto;
import com.wicket.okrcomponent.integration.dto.QueryConfItemMatchAnswerDetailComReqDto;
import com.wicket.okrframework.integration.dto.*;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.wicket.okrapp.base.service.MOmsEvaObjTargetCycleOsetService;
import com.wicket.okrapp.dal.po.mbg.OmsEvaObjTargetCycleOset;
import com.wicket.okrapp.base.service.dto.req.QueryTargetCycleOsetDetailReq;
import com.wicket.okrapp.common.exception.Assert;
import com.wicket.okrapp.base.service.MOmsTargetObjectiveService;
import com.wicket.okrapp.dal.po.mbg.OmsTargetObjective;
import com.wicket.okrapp.base.service.dto.req.QueryTargetObjectiveDetailReq;
import com.wicket.okrcomponent.integration.dto.QueryConfItemMatchAnswerDetailComRespDto;

import java.util.ArrayList;
import com.wicket.okrcomponent.integration.FwCompConfSchemeClient;
import com.wicket.okrapp.biz.service.TargetCycleService;
import com.wicket.okrapp.base.service.MOmsTargetObjectivePlanExtendService;
import com.wicket.okrapp.base.service.MOmsEvaluationObjectTargetCycleService;
import com.wicket.okrapp.dal.po.mbg.OmsEvaluationObjectTargetCycle;
import com.wicket.okrapp.base.service.dto.req.QueryEvaTargetCycleListReq;
import cn.hutool.core.collection.CollectionUtil;
import com.wicket.okrapp.base.service.MOmsTargetAttributionCycleService;
import com.wicket.okrapp.biz.service.nb.NbTargetContCom;
import com.wicket.okrapp.biz.service.AchievementDockService;
import com.wicket.okrapp.base.service.dto.req.QueryEvaObjTargetCycleListReq;
import com.wicket.okrapp.base.service.dto.req.BatchQueryTargetCycleByContentCodesReq;
import com.wicket.okrapp.biz.service.dto.common.EvaObjTargetCycleDto;
import com.wicket.okrapp.biz.service.InterfaceModeService;
import com.wicket.okrapp.base.service.dto.req.QueryTargetCycleCodeOrderStoMaxListReq;
import com.wicket.okrapp.base.service.dto.req.QueryTargetCycleByOrderNumFormSmallToLagListReq;
import com.wicket.okrcomponent.integration.dto.ObtainOutPutCurrentTreeOrderNumberComRespDto;
import com.wicket.okrcomponent.integration.dto.ObtainOutPutCurrentTreeOrderNumberComReqDto;
import com.wicket.okrcomponent.integration.FwCompInterfaceModeClient;
import com.wicket.okrapp.base.service.MOmsTargetCategoryService;
import com.wicket.okrapp.dal.po.mbg.OmsTargetCategory;
import com.wicket.okrapp.base.service.dto.req.QueryTargetCatDetailReq;
import com.wicket.okrapp.base.service.MOmsTaskService;
import com.wicket.okrapp.base.service.dto.req.QueryTargetObjDetailReq;
import com.wicket.okrapp.biz.service.TargetContentService;
import com.wicket.okrapp.base.service.dto.req.ImplementBatchQueryByContIdTimeSectionReq;
import com.wicket.okrapp.base.service.MOmsEvaluationTemplateService;
import com.wicket.okrapp.dal.po.mbg.OmsEvaluationTemplate;
import com.wicket.okrapp.base.service.dto.req.BatchQueryEvaTempReq;
import com.wicket.okrapp.base.service.dto.req.BatchQueryTargetCatReq;
import com.wicket.okrapp.biz.service.VirtualOrgService;
import com.wicket.okrapp.biz.service.TargetCalcService;
import com.wicket.okrapp.base.service.dto.req.BatchQueryEvaObjTargetCycleTargetReq;
import com.wicket.okrcalc.integration.dto.QueryHighMidBaseWorkCycleDataListComRespDto;
import com.wicket.okrcalc.integration.dto.QueryHighMidBaseWorkCycleDataListComReqDto;
import com.wicket.okrframework.integration.FwBaseOrgClient;
import com.wicket.okrframework.integration.FwBaseInductionRecordClient;
import com.wicket.okrcalc.integration.FwCalcStandardDataClient;
import com.wicket.okrapp.base.service.MOmsExecuteCycleStageService;
import com.wicket.okrapp.base.service.MOmsTargetService;
import com.wicket.okrapp.dal.po.mbg.OmsTarget;
import com.wicket.okrapp.base.service.dto.req.QueryTargetDetailReq;
import com.wicket.okrapp.biz.service.DashboardTargetContentService;

/**
 * @author ：
 * @date ：
 *
 *
 * @version 1.0
 */
@Service
public class TargetContComServiceImpl
  implements com.wicket.okrapp.biz.service.TargetContComService {

  @Resource
  private RedisUtil redisUtil;
@Resource
  private MOmsEvaObjTargetCycleOsetService mOmsEvaObjTargetCycleOsetService;
@Resource
  private MOmsTargetObjectiveService mOmsTargetObjectiveService;
@Resource
  private FwCompConfSchemeClient fwCompConfSchemeClient;
@Resource
  private TargetCycleService targetCycleService;
@Resource
  private MOmsTargetObjectivePlanExtendService mOmsTargetObjectivePlanExtendService;
@Resource
  private MOmsEvaluationObjectTargetCycleService mOmsEvaluationObjectTargetCycleService;
@Resource
  private MOmsTargetAttributionCycleService mOmsTargetAttributionCycleService;
@Resource
  private NbTargetContCom nbTargetContCom;
@Resource
  private AchievementDockService achievementDockService;
@Resource
  private InterfaceModeService interfaceModeService;
@Resource
  private FwCompInterfaceModeClient fwCompInterfaceModeClient;
@Resource
  private MOmsTargetCategoryService mOmsTargetCategoryService;
@Resource
  private MOmsTaskService mOmsTaskService;
@Resource
  private TargetContentService targetContentService;
@Resource
  private MOmsEvaluationTemplateService mOmsEvaluationTemplateService;
@Resource
  private VirtualOrgService virtualOrgService;
@Resource
  private TargetCalcService targetCalcService;
@Resource
  private FwBaseOrgClient fwBaseOrgClient;
@Resource
  private FwBaseInductionRecordClient fwBaseInductionRecordClient;
@Resource
  private FwCalcStandardDataClient fwCalcStandardDataClient;
@Resource
  private MOmsExecuteCycleStageService mOmsExecuteCycleStageService;
@Resource
  private MOmsTargetService mOmsTargetService;
@Resource
private DashboardTargetContentService dashboardTargetContentService;
//@Resource
 //private MCustomFields4Service mCustomFields4Service;
//@Resource
 //private undefinedService undefinedService;



/**
   * D3初始化目标周期目标设置(公共)[9410]
   * gen by moon at 7/17/2024, 1:24:51 AM
   */
  @Trace(operationName = "D3初始化目标周期目标设置(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementInitializeTargetCycleOsetComRespDto implementInitializeTargetCycleOsetCom(ImplementInitializeTargetCycleOsetComReqDto reqDto){
    
      
      //virtualUsage D3准备入参：1查指标详情(公共)  67103
      QueryTargetObjectiveDetailComRespDto queryTargetObjectiveDetailComRespDto = null;
    QueryTargetObjectiveDetailComReqDto queryTargetObjectiveDetailComReqDto=new QueryTargetObjectiveDetailComReqDto();
  queryTargetObjectiveDetailComReqDto.setIsArchive("FALSE");//sourceId:1737961_1_67103
queryTargetObjectiveDetailComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1737962_1_67103
if(reqDto!=null){
      queryTargetObjectiveDetailComReqDto.setObjectiveId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:1737959_1_67103
queryTargetObjectiveDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1737960_1_67103
    }
  
    /*D3准备入参：1查指标详情(公共)[9412]   */
    Assert.isNull(queryTargetObjectiveDetailComReqDto.getObjectiveId(),"D3初始化目标周期目标设置(公共)-D3准备入参：1查指标详情(公共)-指标ID不能为空",false);
Assert.isNull(queryTargetObjectiveDetailComReqDto.getIsArchive(),"D3初始化目标周期目标设置(公共)-D3准备入参：1查指标详情(公共)-是否存档不能为空",false);
Assert.isNull(queryTargetObjectiveDetailComReqDto.getSpaceId(),"D3初始化目标周期目标设置(公共)-D3准备入参：1查指标详情(公共)-创建于空间ID不能为空",false);
      queryTargetObjectiveDetailComRespDto = queryTargetObjectiveDetailCom(queryTargetObjectiveDetailComReqDto)/*vcase invoke 同服务,同domain*/;
      
      
      
//virtualUsage D2准备入参：3 查指标计算方式配置答案（公共）  67105
      QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
    com.wicket.okrcomponent.integration.dto.QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("TARGET_VALUE_COUNT_TYPE");//CUSTOM_CONVENTION//sourceId:1737975_1_67105
queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:1737984_1_67105
if(reqDto!=null){
      queryConfItemMatchAnswerDetailComReqDto.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1737977_1_67105
    }
  
    /*D2准备入参：3 查指标计算方式配置答案（公共）[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjId(),"D3初始化目标周期目标设置(公共)-D2准备入参：3 查指标计算方式配置答案（公共）-开通对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(),"D3初始化目标周期目标设置(公共)-D2准备入参：3 查指标计算方式配置答案（公共）-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(),"D3初始化目标周期目标设置(公共)-D2准备入参：3 查指标计算方式配置答案（公共）-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      
//virtualUsage D3准备入参：5 查指标目标父周期ID（用于查询目标设置是否已存在）  67107
      ObtainEvaObjTargetCycleComRespDto obtainEvaObjTargetCycleComRespDto = null;
    ObtainEvaObjTargetCycleComReqDto obtainEvaObjTargetCycleComReqDto=new ObtainEvaObjTargetCycleComReqDto();
  obtainEvaObjTargetCycleComReqDto.setIsParentCycle("TRUE");//sourceId:1738113_1_67107
obtainEvaObjTargetCycleComReqDto.setIsArchive("FALSE");//sourceId:1738122_1_67107
if(reqDto!=null){
      obtainEvaObjTargetCycleComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1738108_1_67107
obtainEvaObjTargetCycleComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1738109_1_67107
obtainEvaObjTargetCycleComReqDto.setTargetCycleContentId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:1738111_1_67107
obtainEvaObjTargetCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1738120_1_67107
    }
  
    /*D3准备入参：5 查指标目标父周期ID（用于查询目标设置是否已存在）[9380]   */
    Assert.isNull(obtainEvaObjTargetCycleComReqDto.getEvaObjEntityId(),"D3初始化目标周期目标设置(公共)-D3准备入参：5 查指标目标父周期ID（用于查询目标设置是否已存在）-被评对象内容表主键ID不能为空",false);
Assert.isNull(obtainEvaObjTargetCycleComReqDto.getEvaObjTypeCode(),"D3初始化目标周期目标设置(公共)-D3准备入参：5 查指标目标父周期ID（用于查询目标设置是否已存在）-被评对象类型编码不能为空",false);
Assert.isNull(obtainEvaObjTargetCycleComReqDto.getTargetCycleContentId(),"D3初始化目标周期目标设置(公共)-D3准备入参：5 查指标目标父周期ID（用于查询目标设置是否已存在）-关联目标内容ID不能为空",false);
Assert.isNull(obtainEvaObjTargetCycleComReqDto.getIsParentCycle(),"D3初始化目标周期目标设置(公共)-D3准备入参：5 查指标目标父周期ID（用于查询目标设置是否已存在）-是否父周期不能为空",false);
Assert.isNull(obtainEvaObjTargetCycleComReqDto.getEvaluationTemplateId(),"D3初始化目标周期目标设置(公共)-D3准备入参：5 查指标目标父周期ID（用于查询目标设置是否已存在）-冗余评价模板ID不能为空",false);
Assert.isNull(obtainEvaObjTargetCycleComReqDto.getIsArchive(),"D3初始化目标周期目标设置(公共)-D3准备入参：5 查指标目标父周期ID（用于查询目标设置是否已存在）-是否存档不能为空",false);
      obtainEvaObjTargetCycleComRespDto = targetCycleService.obtainEvaObjTargetCycleCom(obtainEvaObjTargetCycleComReqDto)/*vcase invoke isSameApp*/;
      
      
      
//virtualUsage D3准备入参：4 查询指标被评目标周期列表(公共)  67106
      QueryEvaTargetCycleListComRespDto queryEvaTargetCycleListComRespDto = null;
    QueryEvaTargetCycleListComReqDto queryEvaTargetCycleListComReqDto=new QueryEvaTargetCycleListComReqDto();
  queryEvaTargetCycleListComReqDto.setIsArchive("FALSE");//sourceId:1738061_1_67106
queryEvaTargetCycleListComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1738062_1_67106
if(reqDto!=null){
      queryEvaTargetCycleListComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1738052_1_67106
queryEvaTargetCycleListComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1738053_1_67106
queryEvaTargetCycleListComReqDto.setTargetCycleContentId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:1738055_1_67106
queryEvaTargetCycleListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1738060_1_67106
    }
  
    /*D3准备入参：4 查询指标被评目标周期列表(公共)[9416]   */
    Assert.isNull(queryEvaTargetCycleListComReqDto.getEvaObjEntityId(),"D3初始化目标周期目标设置(公共)-D3准备入参：4 查询指标被评目标周期列表(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaTargetCycleListComReqDto.getEvaObjTypeCode(),"D3初始化目标周期目标设置(公共)-D3准备入参：4 查询指标被评目标周期列表(公共)-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaTargetCycleListComReqDto.getTargetCycleContentId(),"D3初始化目标周期目标设置(公共)-D3准备入参：4 查询指标被评目标周期列表(公共)-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaTargetCycleListComReqDto.getEvaluationTemplateId(),"D3初始化目标周期目标设置(公共)-D3准备入参：4 查询指标被评目标周期列表(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaTargetCycleListComReqDto.getIsArchive(),"D3初始化目标周期目标设置(公共)-D3准备入参：4 查询指标被评目标周期列表(公共)-是否存档不能为空",false);
Assert.isNull(queryEvaTargetCycleListComReqDto.getSpaceId(),"D3初始化目标周期目标设置(公共)-D3准备入参：4 查询指标被评目标周期列表(公共)-创建于空间ID不能为空",false);
      queryEvaTargetCycleListComRespDto = queryEvaTargetCycleListCom(queryEvaTargetCycleListComReqDto)/*vcase invoke 同服务,同domain*/;
      
      
      
if((reqDto!= null&&  reqDto.getCalcBusinessScence() !=null && reqDto.getCalcBusinessScence().equals("OKR_SUBJECT_PERSONAL")&&!(queryTargetObjectiveDetailComRespDto!= null&&  queryTargetObjectiveDetailComRespDto.getTargetValueType() !=null && queryTargetObjectiveDetailComRespDto.getTargetValueType().equals("SUBJECTIVE_QUALITATIVE"))&&obtainEvaObjTargetCycleComRespDto!= null&&  obtainEvaObjTargetCycleComRespDto.getIndicatorKind() !=null && obtainEvaObjTargetCycleComRespDto.getIndicatorKind().equals("KEY_RESULTS"))) {
        //if((D3初始化目标周期目标设置(公共).计算业务场景 等于 OKR责任主体个人 and D3准备入参：1查指标详情(公共).冗余指标业务类型 不等于 主观定性 and D3准备入参：5 查指标目标父周期ID（用于查询目标设置是否已存在）.OKR目标属性 等于 关键成果KR))  67100
        
QueryTargetCycleOsetDetailComRespDto queryTargetCycleOsetDetailComRespDto = null;
    if(obtainEvaObjTargetCycleComRespDto !=null){
          QueryTargetCycleOsetDetailComReqDto queryTargetCycleOsetDetailComReqDto=new QueryTargetCycleOsetDetailComReqDto();
  queryTargetCycleOsetDetailComReqDto.setIsArchive("FALSE");//sourceId:1738102_1_67108
queryTargetCycleOsetDetailComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1738103_1_67108
if(obtainEvaObjTargetCycleComRespDto!=null){
      queryTargetCycleOsetDetailComReqDto.setOkrPsEvaObjTargetCycleId(obtainEvaObjTargetCycleComRespDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1738100_1_67108
    }
if(reqDto!=null){
      queryTargetCycleOsetDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1738101_1_67108
    }
  
    /*D3查询目标周期目标设置详情(公共)[9418]   */
    Assert.isNull(queryTargetCycleOsetDetailComReqDto.getEvaluationTemplateId(),"D3初始化目标周期目标设置(公共)-D3查询目标周期目标设置详情(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetCycleOsetDetailComReqDto.getIsArchive(),"D3初始化目标周期目标设置(公共)-D3查询目标周期目标设置详情(公共)-是否存档不能为空",false);
Assert.isNull(queryTargetCycleOsetDetailComReqDto.getSpaceId(),"D3初始化目标周期目标设置(公共)-D3查询目标周期目标设置详情(公共)-创建于空间ID不能为空",false);
      queryTargetCycleOsetDetailComRespDto = queryTargetCycleOsetDetailCom(queryTargetCycleOsetDetailComReqDto)/*vcase invoke 同服务,同domain*/;
      
      
      
           }
if((queryTargetCycleOsetDetailComRespDto!= null&& queryTargetCycleOsetDetailComRespDto.getEvaObjOsetId() == null )) {
        //if(D3查KR目标父周期目标设置(用于判断是否已存在).被评对象目标设置ID 值等于空 )  67109
        
boolean bOOLEAN ;
    if(queryEvaTargetCycleListComRespDto !=null&&queryTargetObjectiveDetailComRespDto !=null&&queryConfItemMatchAnswerDetailComRespDto !=null){
          List<OmsEvaObjTargetCycleOset> listOmsEvaObjTargetCycleOset=new ArrayList<>();
  if(queryEvaTargetCycleListComRespDto!= null&&  queryEvaTargetCycleListComRespDto.getEvaObjTargetCycleList() !=null&& !CollectionUtil.isEmpty(queryEvaTargetCycleListComRespDto.getEvaObjTargetCycleList())){
      QueryTargetObjectiveDetailComRespDto finalQueryTargetObjectiveDetailComRespDto = queryTargetObjectiveDetailComRespDto;
      QueryConfItemMatchAnswerDetailComRespDto finalQueryConfItemMatchAnswerDetailComRespDto = queryConfItemMatchAnswerDetailComRespDto;
      listOmsEvaObjTargetCycleOset = //objList-to-objLists
        queryEvaTargetCycleListComRespDto.getEvaObjTargetCycleList().stream().map(item -> {
      OmsEvaObjTargetCycleOset elm = new OmsEvaObjTargetCycleOset();
elm.setIsBeQuote("FALSE");//sourceId:349362_2_67110
elm.setIsAlreadyQuote("FALSE");//sourceId:349363_2_67110
if(item!=null){
      elm.setOkrPsEvaObjTargetCycleId(item.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:349345_2_67110
    }
if(finalQueryTargetObjectiveDetailComRespDto !=null){
      elm.setUnit(finalQueryTargetObjectiveDetailComRespDto.getUnit());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:349349_2_67110
elm.setTargetValueType(finalQueryTargetObjectiveDetailComRespDto.getTargetValueType());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:349351_2_67110
    }
if(finalQueryConfItemMatchAnswerDetailComRespDto !=null){
      elm.setTargetValueCountType(finalQueryConfItemMatchAnswerDetailComRespDto.getEndValue());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:349350_2_67110
    }
if(reqDto!=null){
      elm.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:349359_2_67110
elm.setBatchCode(reqDto.getBatchCode());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:349360_2_67110
elm.setCreateBatchCode(reqDto.getBatchCode());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:349361_2_67110
    }
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:1738068_1_67110
    }
  
    /*3-3-09-01批量增被评对象目标周期目标[4723]   */
    
      bOOLEAN = mOmsEvaObjTargetCycleOsetService.batchAddEvaObjTargetCycleTarget(listOmsEvaObjTargetCycleOset)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
           }
      }
      }
else if((reqDto!= null&&  reqDto.getCalcBusinessScence() !=null && reqDto.getCalcBusinessScence().equals("OKR_SUBJECT_DEPT")&&obtainEvaObjTargetCycleComRespDto!= null&&  obtainEvaObjTargetCycleComRespDto.getIsCustomObjective() !=null && obtainEvaObjTargetCycleComRespDto.getIsCustomObjective().equals("TRUE"))){
       //elseif((D3初始化目标周期目标设置(公共).计算业务场景 等于 OKR责任主体部门 and D3准备入参：5 查指标目标父周期ID（用于查询目标设置是否已存在）.是否自定义OKR目标 等于 是))  67101
      
//processBranchName:正常结束 ,processBranchId:67126
        
    }
else if((reqDto!= null&&  reqDto.getCalcBusinessScence() !=null && reqDto.getCalcBusinessScence().equals("EVA_PORTRAIT")&&!(queryTargetObjectiveDetailComRespDto!= null&&  queryTargetObjectiveDetailComRespDto.getTargetValueType() !=null && queryTargetObjectiveDetailComRespDto.getTargetValueType().equals("SUBJECTIVE_QUALITATIVE")))){
       //elseif((D3初始化目标周期目标设置(公共).计算业务场景 等于 评价画像 and D3准备入参：1查指标详情(公共).冗余指标业务类型 不等于 主观定性))  67102
      
QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_2 = null;
    if(obtainEvaObjTargetCycleComRespDto !=null){
          QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_1=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto_1.setConfItemCode("PERFORMANCE_WEIGHT_SETTING_OBJECT");//CUSTOM_CONVENTION//sourceId:1738032_1_67111
queryConfItemMatchAnswerDetailComReqDto_1.setIsPlatData("FALSE");//sourceId:1738041_1_67111
if(obtainEvaObjTargetCycleComRespDto!=null){
      queryConfItemMatchAnswerDetailComReqDto_1.setResultAspObjId(obtainEvaObjTargetCycleComRespDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1738034_1_67111
    }
  
    /*D2查绩效权重目标设置对象配置答案[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getResultAspObjId(),"D3初始化目标周期目标设置(公共)-D2查绩效权重目标设置对象配置答案-开通对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getConfItemCode(),"D3初始化目标周期目标设置(公共)-D2查绩效权重目标设置对象配置答案-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getIsPlatData(),"D3初始化目标周期目标设置(公共)-D2查绩效权重目标设置对象配置答案-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto_2 = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      
           }
if((queryConfItemMatchAnswerDetailComRespDto_2!= null&&  queryConfItemMatchAnswerDetailComRespDto_2.getEndValue() !=null && queryConfItemMatchAnswerDetailComRespDto_2.getEndValue().equals("EVA_PORTRAIT")&&reqDto!= null&&  reqDto.getEvaObjTypeCode() !=null && reqDto.getEvaObjTypeCode().equals("EVA_PORTRAIT"))) {
        //if((D2查绩效权重目标设置对象配置答案.答案值 等于 评价画像 and D3初始化目标周期目标设置(公共).被评对象类型编码 等于 评价画像))  67112
        
QueryTargetCycleOsetDetailComRespDto queryTargetCycleOsetDetailComRespDto_2 = null;
    if(obtainEvaObjTargetCycleComRespDto !=null){
          QueryTargetCycleOsetDetailComReqDto queryTargetCycleOsetDetailComReqDto_1=new QueryTargetCycleOsetDetailComReqDto();
  queryTargetCycleOsetDetailComReqDto_1.setIsArchive("FALSE");//sourceId:1738102_1_67118
queryTargetCycleOsetDetailComReqDto_1.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1738103_1_67118
if(obtainEvaObjTargetCycleComRespDto!=null){
      queryTargetCycleOsetDetailComReqDto_1.setEvaPortraitTargetCycleId(obtainEvaObjTargetCycleComRespDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1738096_1_67118
    }
  
    /*D3查询目标周期目标设置详情(公共)[9418]   */
    Assert.isNull(queryTargetCycleOsetDetailComReqDto_1.getEvaluationTemplateId(),"D3初始化目标周期目标设置(公共)-D3查询目标周期目标设置详情(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetCycleOsetDetailComReqDto_1.getIsArchive(),"D3初始化目标周期目标设置(公共)-D3查询目标周期目标设置详情(公共)-是否存档不能为空",false);
Assert.isNull(queryTargetCycleOsetDetailComReqDto_1.getSpaceId(),"D3初始化目标周期目标设置(公共)-D3查询目标周期目标设置详情(公共)-创建于空间ID不能为空",false);
      queryTargetCycleOsetDetailComRespDto_2 = queryTargetCycleOsetDetailCom(queryTargetCycleOsetDetailComReqDto_1)/*vcase invoke 同服务,同domain*/;
      
      
      
           }
if((queryTargetCycleOsetDetailComRespDto_2!= null&& queryTargetCycleOsetDetailComRespDto_2.getEvaObjOsetId() == null )) {
        //if(D3查询指标评价画像目标周期目标设置(用于判断是否已存在).被评对象目标设置ID 值等于空 )  67119
        
boolean bOOLEAN_1 ;
    if(queryEvaTargetCycleListComRespDto !=null&&queryTargetObjectiveDetailComRespDto !=null&&queryConfItemMatchAnswerDetailComRespDto !=null){
          List<OmsEvaObjTargetCycleOset> listOmsEvaObjTargetCycleOset_1=new ArrayList<>();
  if(queryEvaTargetCycleListComRespDto!= null&&  queryEvaTargetCycleListComRespDto.getEvaObjTargetCycleList() !=null&& !CollectionUtil.isEmpty(queryEvaTargetCycleListComRespDto.getEvaObjTargetCycleList())){
      QueryTargetObjectiveDetailComRespDto finalQueryTargetObjectiveDetailComRespDto1 = queryTargetObjectiveDetailComRespDto;
      QueryConfItemMatchAnswerDetailComRespDto finalQueryConfItemMatchAnswerDetailComRespDto1 = queryConfItemMatchAnswerDetailComRespDto;
      listOmsEvaObjTargetCycleOset_1 = //objList-to-objLists
        queryEvaTargetCycleListComRespDto.getEvaObjTargetCycleList().stream().map(item -> {
      OmsEvaObjTargetCycleOset elm = new OmsEvaObjTargetCycleOset();
elm.setIsBeQuote("FALSE");//sourceId:349362_2_67120
elm.setIsAlreadyQuote("FALSE");//sourceId:349363_2_67120
if(item!=null){
      elm.setEvaPortraitTargetCycleId(item.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:349341_2_67120
    }
if(finalQueryTargetObjectiveDetailComRespDto1 !=null){
      elm.setUnit(finalQueryTargetObjectiveDetailComRespDto1.getUnit());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:349349_2_67120
elm.setTargetValueType(finalQueryTargetObjectiveDetailComRespDto1.getTargetValueType());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:349351_2_67120
    }
if(finalQueryConfItemMatchAnswerDetailComRespDto1 !=null){
      elm.setTargetValueCountType(finalQueryConfItemMatchAnswerDetailComRespDto1.getEndValue());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:349350_2_67120
    }
if(reqDto!=null){
      elm.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:349359_2_67120
elm.setBatchCode(reqDto.getBatchCode());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:349360_2_67120
elm.setCreateBatchCode(reqDto.getBatchCode());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:349361_2_67120
    }
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:1738068_1_67120
    }
  
    /*3-3-09-01批量增被评对象目标周期目标[4723]   */
    
      bOOLEAN_1 = mOmsEvaObjTargetCycleOsetService.batchAddEvaObjTargetCycleTarget(listOmsEvaObjTargetCycleOset_1)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
           }
      }
      }
else if((queryConfItemMatchAnswerDetailComRespDto_2!= null&&  queryConfItemMatchAnswerDetailComRespDto_2.getEndValue() !=null && queryConfItemMatchAnswerDetailComRespDto_2.getEndValue().equals("EVA_OBJECT")&&reqDto!= null&&  reqDto.getEvaObjTypeCode() !=null && reqDto.getEvaObjTypeCode().equals("EVA_OBJECT"))){
       //elseif((D2查绩效权重目标设置对象配置答案.答案值 等于 评价对象 and D3初始化目标周期目标设置(公共).被评对象类型编码 等于 评价对象))  67113
      
QueryTargetCycleOsetDetailComRespDto queryTargetCycleOsetDetailComRespDto_3 = null;
    if(obtainEvaObjTargetCycleComRespDto !=null){
          QueryTargetCycleOsetDetailComReqDto queryTargetCycleOsetDetailComReqDto_2=new QueryTargetCycleOsetDetailComReqDto();
  queryTargetCycleOsetDetailComReqDto_2.setIsArchive("FALSE");//sourceId:1738102_1_67121
queryTargetCycleOsetDetailComReqDto_2.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1738103_1_67121
if(obtainEvaObjTargetCycleComRespDto!=null){
      queryTargetCycleOsetDetailComReqDto_2.setEvaObjTargetCycleId(obtainEvaObjTargetCycleComRespDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1738097_1_67121
    }
if(reqDto!=null){
      queryTargetCycleOsetDetailComReqDto_2.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1738101_1_67121
    }
  
    /*D3查询目标周期目标设置详情(公共)[9418]   */
    Assert.isNull(queryTargetCycleOsetDetailComReqDto_2.getEvaluationTemplateId(),"D3初始化目标周期目标设置(公共)-D3查询目标周期目标设置详情(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetCycleOsetDetailComReqDto_2.getIsArchive(),"D3初始化目标周期目标设置(公共)-D3查询目标周期目标设置详情(公共)-是否存档不能为空",false);
Assert.isNull(queryTargetCycleOsetDetailComReqDto_2.getSpaceId(),"D3初始化目标周期目标设置(公共)-D3查询目标周期目标设置详情(公共)-创建于空间ID不能为空",false);
      queryTargetCycleOsetDetailComRespDto_3 = queryTargetCycleOsetDetailCom(queryTargetCycleOsetDetailComReqDto_2)/*vcase invoke 同服务,同domain*/;
      
      
      
           }
if((queryTargetCycleOsetDetailComRespDto_3!= null&& queryTargetCycleOsetDetailComRespDto_3.getEvaObjOsetId() == null )) {
        //if(D3查询指标评价对象目标周期目标设置(用于判断是否已存在).被评对象目标设置ID 值等于空 )  67122
        
boolean bOOLEAN_2 ;
    if(queryEvaTargetCycleListComRespDto !=null&&queryTargetObjectiveDetailComRespDto !=null&&queryConfItemMatchAnswerDetailComRespDto !=null){
          List<OmsEvaObjTargetCycleOset> listOmsEvaObjTargetCycleOset_2=new ArrayList<>();
  if(queryEvaTargetCycleListComRespDto!= null&&  queryEvaTargetCycleListComRespDto.getEvaObjTargetCycleList() !=null&& !CollectionUtil.isEmpty(queryEvaTargetCycleListComRespDto.getEvaObjTargetCycleList())){
      QueryTargetObjectiveDetailComRespDto finalQueryTargetObjectiveDetailComRespDto2 = queryTargetObjectiveDetailComRespDto;
      QueryConfItemMatchAnswerDetailComRespDto finalQueryConfItemMatchAnswerDetailComRespDto2 = queryConfItemMatchAnswerDetailComRespDto;
      listOmsEvaObjTargetCycleOset_2 = //objList-to-objLists
        queryEvaTargetCycleListComRespDto.getEvaObjTargetCycleList().stream().map(item -> {
      OmsEvaObjTargetCycleOset elm = new OmsEvaObjTargetCycleOset();
elm.setIsBeQuote("FALSE");//sourceId:349362_2_67123
elm.setIsAlreadyQuote("FALSE");//sourceId:349363_2_67123
if(item!=null){
      elm.setEvaObjTargetCycleId(item.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:349342_2_67123
            }
            if(finalQueryTargetObjectiveDetailComRespDto2 !=null){
      elm.setUnit(finalQueryTargetObjectiveDetailComRespDto2.getUnit());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:349349_2_67123
elm.setTargetValueType(finalQueryTargetObjectiveDetailComRespDto2.getTargetValueType());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:349351_2_67123
            }
            if(finalQueryConfItemMatchAnswerDetailComRespDto2 !=null){
      elm.setTargetValueCountType(finalQueryConfItemMatchAnswerDetailComRespDto2.getEndValue());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:349350_2_67123
            }
            if(reqDto!=null){
      elm.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:349359_2_67123
elm.setBatchCode(reqDto.getBatchCode());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:349360_2_67123
elm.setCreateBatchCode(reqDto.getBatchCode());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:349361_2_67123
            }
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:1738068_1_67123
    }

    /*3-3-09-01批量增被评对象目标周期目标[4723]   */

      bOOLEAN_2 = mOmsEvaObjTargetCycleOsetService.batchAddEvaObjTargetCycleTarget(listOmsEvaObjTargetCycleOset_2)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
           }
      }
    }
else{
       //else  67116
      
//异常结束 67117
      throw new BizException("C00028","对不起，没有数据！！",false);
    }
    }
ImplementInitializeTargetCycleOsetComRespDto retData = new ImplementInitializeTargetCycleOsetComRespDto();
  
  

  
  
return retData;
  }
/**
   * D3查询目标周期目标设置详情(公共)[9418]
   * gen by moon at 4/19/2024, 11:00:22 PM
   */
  @Trace(operationName = "D3查询目标周期目标设置详情(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryTargetCycleOsetDetailComRespDto queryTargetCycleOsetDetailCom(QueryTargetCycleOsetDetailComReqDto reqDto){
    
      
      OmsEvaObjTargetCycleOset omsEvaObjTargetCycleOset_1 =null;
//步骤0: 3-3-09-01查询目标周期目标设置详情 - queryTargetCycleOsetDetail
     OmsEvaObjTargetCycleOset omsEvaObjTargetCycleOset = null;
    QueryTargetCycleOsetDetailReq queryTargetCycleOsetDetailReq=new QueryTargetCycleOsetDetailReq();
  if(reqDto!=null){
      queryTargetCycleOsetDetailReq.setEvaPortraitTargetCycleId(reqDto.getEvaPortraitTargetCycleId());//SimpleFieldAssign//sourceId:1738078_1
queryTargetCycleOsetDetailReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1738079_1
queryTargetCycleOsetDetailReq.setMLevelEvaObjTargetCycleId(reqDto.getMLevelEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1738080_1
queryTargetCycleOsetDetailReq.setOkrDptEvaObjTargetCycleId(reqDto.getOkrDptEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1738081_1
queryTargetCycleOsetDetailReq.setOkrPsEvaObjTargetCycleId(reqDto.getOkrPsEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1738082_1
queryTargetCycleOsetDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1738083_1
queryTargetCycleOsetDetailReq.setIsArchive(reqDto.getIsArchive());//SimpleFieldAssign//sourceId:1738084_1
queryTargetCycleOsetDetailReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1738085_1
    }
  
    /*3-3-09-01查询目标周期目标设置详情[9417]   */
    Assert.isNull(queryTargetCycleOsetDetailReq.getEvaluationTemplateId(),"D3查询目标周期目标设置详情(公共)-3-3-09-01查询目标周期目标设置详情-冗余评价模板ID不能为空",false);
      omsEvaObjTargetCycleOset = mOmsEvaObjTargetCycleOsetService.queryTargetCycleOsetDetail(queryTargetCycleOsetDetailReq)/*vcase invoke 本地 method 方法调用;*/;
      
      
      omsEvaObjTargetCycleOset_1 = omsEvaObjTargetCycleOset;
    
QueryTargetCycleOsetDetailComRespDto retData = new QueryTargetCycleOsetDetailComRespDto();
  if(omsEvaObjTargetCycleOset_1!=null){
      retData.setEvaObjOsetId(omsEvaObjTargetCycleOset_1.getEvaObjOsetId());//SimpleFieldAssign//sourceId:1738095_1
    }
  

  
  
return retData;
  }
/**
   * D3查询被评目标周期列表(公共)[9416]
   * gen by moon at 7/17/2024, 1:24:53 AM
   */
  @Trace(operationName = "D3查询被评目标周期列表(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryEvaTargetCycleListComRespDto queryEvaTargetCycleListCom(QueryEvaTargetCycleListComReqDto reqDto){
    
      
      List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle_1 =new ArrayList<>();
//步骤0: 3-3-09查询被评目标周期列表 - queryEvaTargetCycleList
     List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle =new ArrayList<>();
    QueryEvaTargetCycleListReq queryEvaTargetCycleListReq=new QueryEvaTargetCycleListReq();
  if(reqDto!=null){
      queryEvaTargetCycleListReq.setParentEvaObjTargetCycleId(reqDto.getParentEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1771028_1
      queryEvaTargetCycleListReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1738008_1
queryEvaTargetCycleListReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1738009_1
queryEvaTargetCycleListReq.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1738010_1
queryEvaTargetCycleListReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1738011_1
queryEvaTargetCycleListReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1738012_1
queryEvaTargetCycleListReq.setIsParentCycle(reqDto.getIsParentCycle());//SimpleFieldAssign//sourceId:1738013_1
queryEvaTargetCycleListReq.setIsMetaphase(reqDto.getIsMetaphase());//SimpleFieldAssign//sourceId:1738014_1
queryEvaTargetCycleListReq.setIsSubCycle(reqDto.getIsSubCycle());//SimpleFieldAssign//sourceId:1738015_1
queryEvaTargetCycleListReq.setTaskStatus(reqDto.getTaskStatus());//SimpleFieldAssign//sourceId:1774416_1
queryEvaTargetCycleListReq.setIsReached(reqDto.getIsReached());//SimpleFieldAssign//sourceId:1771072_1
queryEvaTargetCycleListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1738016_1
queryEvaTargetCycleListReq.setIsArchive(reqDto.getIsArchive());//SimpleFieldAssign//sourceId:1738017_1
queryEvaTargetCycleListReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1774419_1
queryEvaTargetCycleListReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1738018_1
    }
  
    /*3-3-09查询被评目标周期列表[9415]   */
    Assert.isNull(queryEvaTargetCycleListReq.getEvaluationTemplateId(),"D3查询被评目标周期列表(公共)-3-3-09查询被评目标周期列表-冗余评价模板ID不能为空",false);
      listOmsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaTargetCycleList(queryEvaTargetCycleListReq)/*vcase invoke 本地 method 方法调用;*/;
      
      
      listOmsEvaluationObjectTargetCycle_1 = listOmsEvaluationObjectTargetCycle;
    
QueryEvaTargetCycleListComRespDto retData = new QueryEvaTargetCycleListComRespDto();
  retData.setEvaObjTargetCycleList(listOmsEvaluationObjectTargetCycle_1.stream().map(item -> BeanUtil.toBean(item, EvaObjTargetCycleDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1738031_1
  

  
  
return retData;
  }
/**
   * D3查询指标详情(公共)[9412]
   * gen by moon at 8/31/2024, 1:03:25 PM
   */
  @Trace(operationName = "D3查询指标详情(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryTargetObjectiveDetailComRespDto queryTargetObjectiveDetailCom(QueryTargetObjectiveDetailComReqDto reqDto){


      OmsTargetObjective omsTargetObjective_1 =null;
//步骤0: 3-3-03查询指标详情 - queryTargetObjectiveDetail
     OmsTargetObjective omsTargetObjective = null;
    QueryTargetObjectiveDetailReq queryTargetObjectiveDetailReq=new QueryTargetObjectiveDetailReq();
  if(reqDto!=null){
      queryTargetObjectiveDetailReq.setObjectiveId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:1737920_1
queryTargetObjectiveDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1737921_1
queryTargetObjectiveDetailReq.setIsArchive(reqDto.getIsArchive());//SimpleFieldAssign//sourceId:1737922_1
queryTargetObjectiveDetailReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1797557_1
queryTargetObjectiveDetailReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1737923_1
    }

    /*3-3-03查询指标详情[9411]   */

      omsTargetObjective = mOmsTargetObjectiveService.queryTargetObjectiveDetail(queryTargetObjectiveDetailReq)/*vcase invoke 本地 method 方法调用;*/;


      omsTargetObjective_1 = omsTargetObjective;

QueryTargetObjectiveDetailComRespDto retData = new QueryTargetObjectiveDetailComRespDto();
  if(omsTargetObjective_1!=null){
      retData.setObjectiveId(omsTargetObjective_1.getObjectiveId());//SimpleFieldAssign//sourceId:1737933_1
retData.setObjectiveName(omsTargetObjective_1.getObjectiveName());//SimpleFieldAssign//sourceId:1992446_1
retData.setObjectiveShortName(omsTargetObjective_1.getObjectiveShortName());//SimpleFieldAssign//sourceId:1992447_1
retData.setTargetValueType(omsTargetObjective_1.getTargetValueType());//SimpleFieldAssign//sourceId:1737934_1
retData.setIsLeft(omsTargetObjective_1.getIsLeft());//SimpleFieldAssign//sourceId:1737935_1
retData.setUnit(omsTargetObjective_1.getUnit());//SimpleFieldAssign//sourceId:1737936_1
retData.setDigitalUnit(omsTargetObjective_1.getDigitalUnit());//SimpleFieldAssign//sourceId:1737937_1
retData.setIsLastObjective(omsTargetObjective_1.getIsLastObjective());//SimpleFieldAssign//sourceId:1777707_1
retData.setLevelNumber(omsTargetObjective_1.getLevelNumber());//SimpleFieldAssign//sourceId:1797566_1
retData.setParentObjectiveId(omsTargetObjective_1.getParentObjectiveId());//SimpleFieldAssign//sourceId:1797975_1
retData.setRootObjectiveId(omsTargetObjective_1.getRootObjectiveId());//SimpleFieldAssign//sourceId:1797567_1
retData.setRootTargetCategoryId(omsTargetObjective_1.getRootTargetCategoryId());//SimpleFieldAssign//sourceId:1797568_1
retData.setTargetId(omsTargetObjective_1.getTargetId());//SimpleFieldAssign//sourceId:1797569_1
    }




return retData;
  }
/**
   * D3分析对齐时间与是否对齐(公共)[9574]
   * gen by moon at 5/13/2024, 11:21:07 PM
   */
  @Trace(operationName = "D3分析对齐时间与是否对齐(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AnalysisAlignmentTimeAndIsAlignmentComRespDto analysisAlignmentTimeAndIsAlignmentCom(AnalysisAlignmentTimeAndIsAlignmentComReqDto reqDto){


      ImplementFiveReceivingFieldRespDto receptionServiceRes_3 =null;
//virtualUsage M3接收入参字段  68381
      //ModelCode: receptionService
        ImplementFiveReceivingFieldRespDto receptionServiceRes = null;
    ImplementFiveReceivingFieldReqDto receptionServiceReq=new ImplementFiveReceivingFieldReqDto();
  receptionServiceReq.setCustomField1("TRUE");//CUSTOM_CONVENTION//sourceId:1797142_1_68381
receptionServiceReq.setCustomField2("FALSE");//CUSTOM_CONVENTION//sourceId:1797144_1_68381
if(reqDto!=null){
      receptionServiceReq.setObjectiveId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:1796761_1_68381
receptionServiceReq.setPlanStartTime(reqDto.getPlanStartTime());//SimpleFieldAssign//sourceId:1796763_1_68381
    }

    /*M3接收入参字段[8467]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getPlanStartTime(),"D3分析对齐时间与是否对齐(公共)-M3接收入参字段-计划开始时间不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField1(),"D3分析对齐时间与是否对齐(公共)-M3接收入参字段-自定义字段1不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField2(),"D3分析对齐时间与是否对齐(公共)-M3接收入参字段-自定义字段2不能为空",false);
      receptionServiceRes = nbTargetContCom.implementFiveReceivingField(receptionServiceReq);



if((reqDto!= null&& reqDto.getObjectiveId() != null )) {
        //if(D3分析对齐时间与是否对齐(公共).对齐指标ID 值不等于空 )  68380

//ModelCode: receptionService
        ImplementFiveReceivingFieldRespDto receptionServiceRes_2 = null;
    ImplementFiveReceivingFieldReqDto receptionServiceReq_1=new ImplementFiveReceivingFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_1.setIsAlignment(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1797141_1_68382
    }
if(reqDto!=null){
      receptionServiceReq_1.setAlignmentTime(reqDto.getPlanStartTime());//SimpleFieldAssign//sourceId:1797140_1_68382
    }

    /*M3接收对齐时间出参[8467]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getIsAlignment(),"D3分析对齐时间与是否对齐(公共)-M3接收对齐时间出参-是否对齐不能为空",false);
      receptionServiceRes_2 = nbTargetContCom.implementFiveReceivingField(receptionServiceReq_1);


      receptionServiceRes_3 = receptionServiceRes_2;
      }
else if((reqDto!= null&& reqDto.getObjectiveId() == null )){
       //elseif(D3分析对齐时间与是否对齐(公共).对齐指标ID 值等于空 )  68383

//ModelCode: receptionService
        ImplementFiveReceivingFieldRespDto receptionServiceRes_4 = null;
    ImplementFiveReceivingFieldReqDto receptionServiceReq_2=new ImplementFiveReceivingFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_2.setIsAlignment(receptionServiceRes.getCustomField2());//SimpleFieldAssign//sourceId:1797141_1_68384
    }

    /*M3接收对齐时间出参[8467]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getIsAlignment(),"D3分析对齐时间与是否对齐(公共)-M3接收对齐时间出参-是否对齐不能为空",false);
      receptionServiceRes_4 = nbTargetContCom.implementFiveReceivingField(receptionServiceReq_2);


      receptionServiceRes_3 = receptionServiceRes_4;
    }
AnalysisAlignmentTimeAndIsAlignmentComRespDto retData = new AnalysisAlignmentTimeAndIsAlignmentComRespDto();
  if(receptionServiceRes_3!=null){
      retData.setIsAlignment(receptionServiceRes_3.getIsAlignment());//SimpleFieldAssign//sourceId:1797146_1
retData.setAlignmentTime(receptionServiceRes_3.getAlignmentTime());//SimpleFieldAssign//sourceId:1797147_1
    }




return retData;
  }
/**
   * D3分析对齐指标关联信息(公共)[9575]
   * gen by moon at 5/13/2024, 11:21:22 PM
   */
  @Trace(operationName = "D3分析对齐指标关联信息(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AnalysisAlignmentObjectiveRelevancyInfoComRespDto analysisAlignmentObjectiveRelevancyInfoCom(AnalysisAlignmentObjectiveRelevancyInfoComReqDto reqDto){


      AnalysisAlignmentTimeAndIsAlignmentComRespDto analysisAlignmentTimeAndIsAlignmentComRespDto_1 =null;
ImplementFiveReceivingFieldRespDto receptionServiceRes_1 =null;
//virtualUsage D3分析对齐时间与是否对齐(公共)  68385
      AnalysisAlignmentTimeAndIsAlignmentComRespDto analysisAlignmentTimeAndIsAlignmentComRespDto = null;
    AnalysisAlignmentTimeAndIsAlignmentComReqDto analysisAlignmentTimeAndIsAlignmentComReqDto=new AnalysisAlignmentTimeAndIsAlignmentComReqDto();
  if(reqDto!=null){
      analysisAlignmentTimeAndIsAlignmentComReqDto.setObjectiveId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:1797148_1_68385
analysisAlignmentTimeAndIsAlignmentComReqDto.setPlanStartTime(reqDto.getPlanStartTime());//SimpleFieldAssign//sourceId:1797149_1_68385
    }

    /*D3分析对齐时间与是否对齐(公共)[9574]   */
    Assert.isNull(analysisAlignmentTimeAndIsAlignmentComReqDto.getPlanStartTime(),"D3分析对齐指标关联信息(公共)-D3分析对齐时间与是否对齐(公共)-计划开始时间不能为空",false);
      analysisAlignmentTimeAndIsAlignmentComRespDto = analysisAlignmentTimeAndIsAlignmentCom(analysisAlignmentTimeAndIsAlignmentComReqDto)/*vcase invoke 同服务,同domain*/;


      analysisAlignmentTimeAndIsAlignmentComRespDto_1 = analysisAlignmentTimeAndIsAlignmentComRespDto;
if((reqDto!= null&& reqDto.getObjectiveId() != null )) {
        //if(D3分析对齐指标关联信息(公共).对齐指标ID 值不等于空 )  68386

QueryObjtiveExtSetDetailComRespDto queryObjtiveExtSetDetailComRespDto = null;
    QueryObjtiveExtSetDetailComReqDto queryObjtiveExtSetDetailComReqDto=new QueryObjtiveExtSetDetailComReqDto();
  queryObjtiveExtSetDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1797530_1_68387
if(reqDto!=null){
      queryObjtiveExtSetDetailComReqDto.setObjectiveId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:1797528_1_68387
queryObjtiveExtSetDetailComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1797531_1_68387
    }

    /*D3查对齐指标OKR属性（用于判断分析关联父级目标内容）[9247]   */
    Assert.isNull(queryObjtiveExtSetDetailComReqDto.getObjectiveId(),"D3分析对齐指标关联信息(公共)-D3查对齐指标OKR属性（用于判断分析关联父级目标内容）-归属指标ID不能为空",false);
Assert.isNull(queryObjtiveExtSetDetailComReqDto.getSubjectLifeCycle(),"D3分析对齐指标关联信息(公共)-D3查对齐指标OKR属性（用于判断分析关联父级目标内容）-主体生命周期不能为空",false);
Assert.isNull(queryObjtiveExtSetDetailComReqDto.getSpaceId(),"D3分析对齐指标关联信息(公共)-D3查对齐指标OKR属性（用于判断分析关联父级目标内容）-创建于空间ID不能为空",false);
      queryObjtiveExtSetDetailComRespDto = achievementDockService.queryObjtiveExtSetDetailCom(queryObjtiveExtSetDetailComReqDto)/*vcase invoke isSameApp*/;



QueryTargetObjectiveDetailComRespDto queryTargetObjectiveDetailComRespDto = null;
    QueryTargetObjectiveDetailComReqDto queryTargetObjectiveDetailComReqDto=new QueryTargetObjectiveDetailComReqDto();
  queryTargetObjectiveDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1797570_1_68395
if(reqDto!=null){
      queryTargetObjectiveDetailComReqDto.setObjectiveId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:1797547_1_68395
queryTargetObjectiveDetailComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1797550_1_68395
    }

    /*D3查询对齐指标详情(公共)[9412]   */
    Assert.isNull(queryTargetObjectiveDetailComReqDto.getObjectiveId(),"D3分析对齐指标关联信息(公共)-D3查询对齐指标详情(公共)-指标ID不能为空",false);
Assert.isNull(queryTargetObjectiveDetailComReqDto.getSubjectLifeCycle(),"D3分析对齐指标关联信息(公共)-D3查询对齐指标详情(公共)-主体生命周期不能为空",false);
Assert.isNull(queryTargetObjectiveDetailComReqDto.getSpaceId(),"D3分析对齐指标关联信息(公共)-D3查询对齐指标详情(公共)-创建于空间ID不能为空",false);
      queryTargetObjectiveDetailComRespDto = queryTargetObjectiveDetailCom(queryTargetObjectiveDetailComReqDto)/*vcase invoke 同服务,同domain*/;



if((queryObjtiveExtSetDetailComRespDto!= null&&  queryObjtiveExtSetDetailComRespDto.getIndicatorKind() !=null && queryObjtiveExtSetDetailComRespDto.getIndicatorKind().equals("KEY_RESULTS"))) {
        //if(D3查对齐指标OKR属性（用于判断分析关联父级目标内容）.OKR目标属性 等于 关键成果KR)  68388

//ModelCode: receptionService
        ImplementFiveReceivingFieldRespDto receptionServiceRes = null;
    if(queryTargetObjectiveDetailComRespDto !=null){
          ImplementFiveReceivingFieldReqDto receptionServiceReq=new ImplementFiveReceivingFieldReqDto();
  if(queryTargetObjectiveDetailComRespDto!=null){
      receptionServiceReq.setRootObjectiveId(queryTargetObjectiveDetailComRespDto.getParentObjectiveId());//SimpleFieldAssign//sourceId:1797965_1_68393
receptionServiceReq.setTargetId(queryTargetObjectiveDetailComRespDto.getTargetId());//SimpleFieldAssign//sourceId:1797967_1_68393
    }

    /*M3接收任务对齐目标关联信息出参[8467]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getRootObjectiveId(),"D3分析对齐指标关联信息(公共)-M3接收任务对齐目标关联信息出参-冗余对齐目标O或一级指标ID不能为空",false);
Assert.isNull(receptionServiceReq.getTargetId(),"D3分析对齐指标关联信息(公共)-M3接收任务对齐目标关联信息出参-冗余对齐目标ID不能为空",false);
      receptionServiceRes = nbTargetContCom.implementFiveReceivingField(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
           }
      }
else if((queryObjtiveExtSetDetailComRespDto!= null&&  queryObjtiveExtSetDetailComRespDto.getIndicatorKind() !=null && queryObjtiveExtSetDetailComRespDto.getIndicatorKind().equals("OBJECTIVES"))){
       //elseif(D3查对齐指标OKR属性（用于判断分析关联父级目标内容）.OKR目标属性 等于 目标O)  68390

//ModelCode: receptionService
        ImplementFiveReceivingFieldRespDto receptionServiceRes_2 = null;
    if(queryTargetObjectiveDetailComRespDto !=null){
          ImplementFiveReceivingFieldReqDto receptionServiceReq_1=new ImplementFiveReceivingFieldReqDto();
  if(queryTargetObjectiveDetailComRespDto!=null){
      receptionServiceReq_1.setRootObjectiveId(queryTargetObjectiveDetailComRespDto.getRootObjectiveId());//SimpleFieldAssign//sourceId:1797965_1_68394
receptionServiceReq_1.setRootTargetCategoryId(queryTargetObjectiveDetailComRespDto.getRootTargetCategoryId());//SimpleFieldAssign//sourceId:1797966_1_68394
receptionServiceReq_1.setTargetId(queryTargetObjectiveDetailComRespDto.getTargetId());//SimpleFieldAssign//sourceId:1797967_1_68394
    }

    /*M3接收任务对齐目标关联信息出参[8467]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getRootObjectiveId(),"D3分析对齐指标关联信息(公共)-M3接收任务对齐目标关联信息出参-冗余对齐目标O或一级指标ID不能为空",false);
Assert.isNull(receptionServiceReq_1.getTargetId(),"D3分析对齐指标关联信息(公共)-M3接收任务对齐目标关联信息出参-冗余对齐目标ID不能为空",false);
      receptionServiceRes_2 = nbTargetContCom.implementFiveReceivingField(receptionServiceReq_1);


      receptionServiceRes_1 = receptionServiceRes_2;
           }
    }
      }
AnalysisAlignmentObjectiveRelevancyInfoComRespDto retData = new AnalysisAlignmentObjectiveRelevancyInfoComRespDto();
  if(analysisAlignmentTimeAndIsAlignmentComRespDto_1!=null){
      retData.setIsAlignment(analysisAlignmentTimeAndIsAlignmentComRespDto_1.getIsAlignment());//SimpleFieldAssign//sourceId:1797977_1
retData.setAlignmentTime(analysisAlignmentTimeAndIsAlignmentComRespDto_1.getAlignmentTime());//SimpleFieldAssign//sourceId:1797978_1
    }
if(receptionServiceRes_1!=null){
      retData.setRootObjectiveId(receptionServiceRes_1.getRootObjectiveId());//SimpleFieldAssign//sourceId:1797979_1
retData.setRootTargetCategoryId(receptionServiceRes_1.getRootTargetCategoryId());//SimpleFieldAssign//sourceId:1797980_1
retData.setTargetId(receptionServiceRes_1.getTargetId());//SimpleFieldAssign//sourceId:1797981_1
    }




return retData;
  }
/**
   * D3批量改目标内容编号(公共)[9586]
   * gen by moon at 5/16/2024, 8:53:24 PM
   */
  @Trace(operationName = "D3批量改目标内容编号(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public BatchUpdateTargetContentNumberComRespDto batchUpdateTargetContentNumberCom(BatchUpdateTargetContentNumberComReqDto reqDto){


      //步骤0: 3-3-09查被评对象目标周期列表（根据周期时间范围） - queryEvaObjTargetCycleList
     List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle =new ArrayList<>();
    QueryEvaObjTargetCycleListReq queryEvaObjTargetCycleListReq=new QueryEvaObjTargetCycleListReq();
  queryEvaObjTargetCycleListReq.setIsArchive("FALSE");//sourceId:1801867_1
if(reqDto!=null){
      queryEvaObjTargetCycleListReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1801865_1
queryEvaObjTargetCycleListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1801866_1
    }

    /*3-3-09查被评对象目标周期列表（根据周期时间范围）[2190]   */
    Assert.isNull(queryEvaObjTargetCycleListReq.getTargetCycleContentId(),"D3批量改目标内容编号(公共)-3-3-09查被评对象目标周期列表（根据周期时间范围）-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getEvaluationTemplateId(),"D3批量改目标内容编号(公共)-3-3-09查被评对象目标周期列表（根据周期时间范围）-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getIsArchive(),"D3批量改目标内容编号(公共)-3-3-09查被评对象目标周期列表（根据周期时间范围）-是否存档不能为空",false);
      listOmsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleList(queryEvaObjTargetCycleListReq)/*vcase invoke 本地 method 方法调用;*/;




//步骤1: 3-3-09-01批量改被评对象目标周期 - batchUpdateEvaObjTargetCycle
     boolean bOOLEAN ;
    if(listOmsEvaluationObjectTargetCycle !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)&& listOmsEvaluationObjectTargetCycle.size()>0 ){
          List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle_2=new ArrayList<>();
  if(listOmsEvaluationObjectTargetCycle!= null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)&&  listOmsEvaluationObjectTargetCycle !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)){
      listOmsEvaluationObjectTargetCycle_2 = //objList-to-objLists
        listOmsEvaluationObjectTargetCycle.stream().map(item -> {
      OmsEvaluationObjectTargetCycle elm = new OmsEvaluationObjectTargetCycle();
      elm.setEvaObjTargetCycleId(item.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:363020_2
elm.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:363023_2
elm.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:363024_2
if(reqDto!=null){
      elm.setTargetContentNumber(reqDto.getTargetContentNumber());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:363022_2
    }
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:1801870_1
    }

    /*3-3-09-01批量改被评对象目标周期[2664]   */

      bOOLEAN = mOmsEvaluationObjectTargetCycleService.batchUpdateEvaObjTargetCycle(listOmsEvaluationObjectTargetCycle_2)/*vcase invoke 本地 method 方法调用;*/;



           }

BatchUpdateTargetContentNumberComRespDto retData = new BatchUpdateTargetContentNumberComRespDto();





return retData;
  }
/**
   * D3执行初始化目标分类编号(公共)[9587]
   * gen by moon at 5/17/2024, 2:19:24 AM
   */
  @Trace(operationName = "D3执行初始化目标分类编号(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementInitializeCategoryNumberComRespDto implementInitializeCategoryNumberCom(ImplementInitializeCategoryNumberComReqDto reqDto){


      ImplementFiveReceivingFieldRespDto receptionServiceRes_3 =null;
if((reqDto!= null&& reqDto.getTargetCategoryNumber() == null )) {
        //if(D3执行初始化目标分类编号(公共).目标分类编号 值等于空 )  68483

//ModelCode: receptionService
        ImplementFiveReceivingFieldRespDto receptionServiceRes = null;
    ImplementFiveReceivingFieldReqDto receptionServiceReq=new ImplementFiveReceivingFieldReqDto();
  receptionServiceReq.setTargetCategoryNumber("TC"+CommonFunctionHelper.getUid());//AUTO_GENERATE//sourceId:1803448_1_68484

    /*M3自定生成目标分类编号[8467]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getTargetCategoryNumber(),"D3执行初始化目标分类编号(公共)-M3自定生成目标分类编号-目标分类编号不能为空",false);
      receptionServiceRes = nbTargetContCom.implementFiveReceivingField(receptionServiceReq);



//ModelCode: receptionService
        ImplementFiveReceivingFieldRespDto receptionServiceRes_2 = null;
    ImplementFiveReceivingFieldReqDto receptionServiceReq_1=new ImplementFiveReceivingFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_1.setTargetCategoryNumber(receptionServiceRes.getTargetCategoryNumber());//SimpleFieldAssign//sourceId:1803445_1_68485
    }

    /*M3接收目标分类编号出参[8467]  用于特殊方法接收上游入参。 */

      receptionServiceRes_2 = nbTargetContCom.implementFiveReceivingField(receptionServiceReq_1);


      receptionServiceRes_3 = receptionServiceRes_2;
      }
else if((reqDto!= null&& reqDto.getTargetCategoryNumber() != null )){
       //elseif(D3执行初始化目标分类编号(公共).目标分类编号 值不等于空 )  68486

//ModelCode: receptionService
        ImplementFiveReceivingFieldRespDto receptionServiceRes_4 = null;
    ImplementFiveReceivingFieldReqDto receptionServiceReq_2=new ImplementFiveReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq_2.setTargetCategoryNumber(reqDto.getTargetCategoryNumber());//SimpleFieldAssign//sourceId:1803445_1_68487
    }

    /*M3接收目标分类编号出参[8467]  用于特殊方法接收上游入参。 */

      receptionServiceRes_4 = nbTargetContCom.implementFiveReceivingField(receptionServiceReq_2);


      receptionServiceRes_3 = receptionServiceRes_4;
    }
ImplementInitializeCategoryNumberComRespDto retData = new ImplementInitializeCategoryNumberComRespDto();
  if(receptionServiceRes_3!=null){
      retData.setTargetCategoryNumber(receptionServiceRes_3.getTargetCategoryNumber());//SimpleFieldAssign//sourceId:1803451_1
    }




return retData;
  }
/**
   * D3查询目标周期祖先数据源列表[9588]
   * gen by moon at 5/17/2024, 2:19:28 AM
   */
  @Trace(operationName = "D3查询目标周期祖先数据源列表")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryTargetCycleAncestorDataOriginListRespDto queryTargetCycleAncestorDataOriginList(QueryTargetCycleAncestorDataOriginListReqDto reqDto){


      List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle_1 =new ArrayList<>();
//步骤0: M3-执行第五接收字段（特殊方法） - implementFiveReceivingField
     //ModelCode: receptionService
        ImplementFiveReceivingFieldRespDto receptionServiceRes = null;
    ImplementFiveReceivingFieldReqDto receptionServiceReq=new ImplementFiveReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setEvaObjTargetCycleCode(reqDto.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:1803845_1
receptionServiceReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1803847_1
receptionServiceReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1803846_1
receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1803848_1
    }

    /*M3接收入参字段[8467]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getEvaObjTargetCycleCode(),"D3查询目标周期祖先数据源列表-M3接收入参字段-被评对象目标周期标识不能为空",false);
Assert.isNull(receptionServiceReq.getEvaObjEntityId(),"D3查询目标周期祖先数据源列表-M3接收入参字段-被评对象内容表主键ID不能为空",false);
Assert.isNull(receptionServiceReq.getEvaObjTypeCode(),"D3查询目标周期祖先数据源列表-M3接收入参字段-被评对象类型编码不能为空",false);
Assert.isNull(receptionServiceReq.getEvaluationTemplateId(),"D3查询目标周期祖先数据源列表-M3接收入参字段-冗余评价模板ID不能为空",false);
      receptionServiceRes = nbTargetContCom.implementFiveReceivingField(receptionServiceReq);




//步骤1: D3-查询找祖先列表(公共) - queryLookAncestorNodeListCom
     QueryLookAncestorNodeListComRespDto queryLookAncestorNodeListComRespDto = null;
    QueryLookAncestorNodeListComReqDto queryLookAncestorNodeListComReqDto=new QueryLookAncestorNodeListComReqDto();
  if(reqDto!=null){
      queryLookAncestorNodeListComReqDto.setComCode(reqDto.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:1803858_1
    }

    /*D3-查询找祖先列表(公共)[5833]   */
    Assert.isNull(queryLookAncestorNodeListComReqDto.getComCode(),"D3查询目标周期祖先数据源列表-D3-查询找祖先列表(公共)-通用编码标识不能为空",false);
      queryLookAncestorNodeListComRespDto = interfaceModeService.queryLookAncestorNodeListCom(queryLookAncestorNodeListComReqDto)/*vcase invoke isSameApp*/;




//步骤2: 3-3-09批量查询目标周期by内容标识 - batchQueryTargetCycleByContentCodes
     List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle =new ArrayList<>();
    if(queryLookAncestorNodeListComRespDto !=null){
          BatchQueryTargetCycleByContentCodesReq batchQueryTargetCycleByContentCodesReq=new BatchQueryTargetCycleByContentCodesReq();
  batchQueryTargetCycleByContentCodesReq.setIsParentCycle("TRUE");//sourceId:1803895_1
batchQueryTargetCycleByContentCodesReq.setIsArchive("FALSE");//sourceId:1803900_1
batchQueryTargetCycleByContentCodesReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1803898_1
if(queryLookAncestorNodeListComRespDto!=null){
      batchQueryTargetCycleByContentCodesReq.setEvaObjTargetCycleList(queryLookAncestorNodeListComRespDto.getLookAncestorNodeList());//list-field-assign//sourceId:1803892_1
    }
if(reqDto!=null){
      batchQueryTargetCycleByContentCodesReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1803893_1
batchQueryTargetCycleByContentCodesReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1803894_1
batchQueryTargetCycleByContentCodesReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1803896_1
    }

    /*3-3-09批量查询目标周期by内容标识[9589]   */
    Assert.isNull(batchQueryTargetCycleByContentCodesReq.getEvaObjEntityId(),"D3查询目标周期祖先数据源列表-3-3-09批量查询目标周期by内容标识-被评对象内容表主键ID不能为空",false);
Assert.isNull(batchQueryTargetCycleByContentCodesReq.getEvaObjTypeCode(),"D3查询目标周期祖先数据源列表-3-3-09批量查询目标周期by内容标识-被评对象类型编码不能为空",false);
Assert.isNull(batchQueryTargetCycleByContentCodesReq.getIsParentCycle(),"D3查询目标周期祖先数据源列表-3-3-09批量查询目标周期by内容标识-是否父周期不能为空",false);
Assert.isNull(batchQueryTargetCycleByContentCodesReq.getEvaluationTemplateId(),"D3查询目标周期祖先数据源列表-3-3-09批量查询目标周期by内容标识-冗余评价模板ID不能为空",false);
Assert.isNull(batchQueryTargetCycleByContentCodesReq.getIsArchive(),"D3查询目标周期祖先数据源列表-3-3-09批量查询目标周期by内容标识-是否存档不能为空",false);
Assert.isNull(batchQueryTargetCycleByContentCodesReq.getSpaceId(),"D3查询目标周期祖先数据源列表-3-3-09批量查询目标周期by内容标识-创建于空间ID不能为空",false);
      listOmsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.batchQueryTargetCycleByContentCodes(batchQueryTargetCycleByContentCodesReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsEvaluationObjectTargetCycle_1 = listOmsEvaluationObjectTargetCycle;
           }

QueryTargetCycleAncestorDataOriginListRespDto retData = new QueryTargetCycleAncestorDataOriginListRespDto();
  retData.setEvaObjTargetCycleList(listOmsEvaluationObjectTargetCycle_1.stream().map(item -> BeanUtil.toBean(item, EvaObjTargetCycleDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1803901_1




return retData;
  }
/**
   * D3执行刷全模板目标内容树排序[9592]
   * gen by moon at 5/17/2024, 11:30:44 PM
   */
  @Trace(operationName = "D3执行刷全模板目标内容树排序")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementBrushTempTargetContTreeOrderNumRespDto implementBrushTempTargetContTreeOrderNum(ImplementBrushTempTargetContTreeOrderNumReqDto reqDto){


      //virtualUsage 3-3-09查目标周期（标识排序小到大）列表  68501
      List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle =new ArrayList<>();
    QueryTargetCycleCodeOrderStoMaxListReq queryTargetCycleCodeOrderStoMaxListReq=new QueryTargetCycleCodeOrderStoMaxListReq();
  queryTargetCycleCodeOrderStoMaxListReq.setIsParentCycle("TRUE");//sourceId:1804345_1_68501
queryTargetCycleCodeOrderStoMaxListReq.setIsArchive("FALSE");//sourceId:1804347_1_68501
if(reqDto!=null){
      queryTargetCycleCodeOrderStoMaxListReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1804342_1_68501
queryTargetCycleCodeOrderStoMaxListReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1804343_1_68501
queryTargetCycleCodeOrderStoMaxListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1804346_1_68501
queryTargetCycleCodeOrderStoMaxListReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1804348_1_68501
    }

    /*3-3-09查目标周期（标识排序小到大）列表[7584]   */
    Assert.isNull(queryTargetCycleCodeOrderStoMaxListReq.getEvaObjEntityId(),"D3执行刷全模板目标内容树排序-3-3-09查目标周期（标识排序小到大）列表-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryTargetCycleCodeOrderStoMaxListReq.getEvaObjTypeCode(),"D3执行刷全模板目标内容树排序-3-3-09查目标周期（标识排序小到大）列表-被评对象类型编码不能为空",false);
Assert.isNull(queryTargetCycleCodeOrderStoMaxListReq.getIsParentCycle(),"D3执行刷全模板目标内容树排序-3-3-09查目标周期（标识排序小到大）列表-是否父周期不能为空",false);
Assert.isNull(queryTargetCycleCodeOrderStoMaxListReq.getEvaluationTemplateId(),"D3执行刷全模板目标内容树排序-3-3-09查目标周期（标识排序小到大）列表-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetCycleCodeOrderStoMaxListReq.getIsArchive(),"D3执行刷全模板目标内容树排序-3-3-09查目标周期（标识排序小到大）列表-是否存档不能为空",false);
Assert.isNull(queryTargetCycleCodeOrderStoMaxListReq.getSpaceId(),"D3执行刷全模板目标内容树排序-3-3-09查目标周期（标识排序小到大）列表-创建于空间ID不能为空",false);
      listOmsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryTargetCycleCodeOrderStoMaxList(queryTargetCycleCodeOrderStoMaxListReq)/*vcase invoke 本地 method 方法调用;*/;



if((listOmsEvaluationObjectTargetCycle!= null&&  listOmsEvaluationObjectTargetCycle !=null && listOmsEvaluationObjectTargetCycle.size()>0)) {
        //if(3-3-09查目标周期（标识排序小到大）列表.被评对象目标周期列表数据集条数 大于 0)  68503

//ModelCode: circulationCollections
        for (OmsEvaluationObjectTargetCycle circulationCollectionsRes: listOmsEvaluationObjectTargetCycle){

if((circulationCollectionsRes!= null&&  circulationCollectionsRes.getTargetCycleContentTypeCode() !=null && circulationCollectionsRes.getTargetCycleContentTypeCode().equals("TARGET"))) {
        //if(M3目标周期发牌【循环开始】.关联目标内容类型编码 等于 目标)  68507

ImplementWriteBackTargetCycleTreeOrderNumberComRespDto implementWriteBackTargetCycleTreeOrderNumberComRespDto = null;
    ImplementWriteBackTargetCycleTreeOrderNumberComReqDto implementWriteBackTargetCycleTreeOrderNumberComReqDto=new ImplementWriteBackTargetCycleTreeOrderNumberComReqDto();
  implementWriteBackTargetCycleTreeOrderNumberComReqDto.setTargetTreeOrderNumber("101");//CUSTOM_CONVENTION//sourceId:1805371_1_68512
if(circulationCollectionsRes!=null){
      implementWriteBackTargetCycleTreeOrderNumberComReqDto.setTargetCycleContentId(circulationCollectionsRes.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1805370_1_68512
    }
if(reqDto!=null){
      implementWriteBackTargetCycleTreeOrderNumberComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1805372_1_68512
implementWriteBackTargetCycleTreeOrderNumberComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1805373_1_68512
    }

    /*D3执行回写目标周期树排序(公共)[9594]   */
    Assert.isNull(implementWriteBackTargetCycleTreeOrderNumberComReqDto.getTargetTreeOrderNumber(),"D3执行刷全模板目标内容树排序-D3执行回写目标周期树排序(公共)-目标树排序不能为空",false);
Assert.isNull(implementWriteBackTargetCycleTreeOrderNumberComReqDto.getTargetCycleContentId(),"D3执行刷全模板目标内容树排序-D3执行回写目标周期树排序(公共)-关联目标内容ID不能为空",false);
Assert.isNull(implementWriteBackTargetCycleTreeOrderNumberComReqDto.getEvaluationTemplateId(),"D3执行刷全模板目标内容树排序-D3执行回写目标周期树排序(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(implementWriteBackTargetCycleTreeOrderNumberComReqDto.getSpaceId(),"D3执行刷全模板目标内容树排序-D3执行回写目标周期树排序(公共)-创建于空间ID不能为空",false);
      implementWriteBackTargetCycleTreeOrderNumberComRespDto = implementWriteBackTargetCycleTreeOrderNumberCom(implementWriteBackTargetCycleTreeOrderNumberComReqDto)/*vcase invoke 同服务,同domain*/;



      }
else{
       //else  68508

ImplementLoopWriteBackTargetCycleTreeOrderNumberComRespDto implementLoopWriteBackTargetCycleTreeOrderNumberComRespDto = null;
    ImplementLoopWriteBackTargetCycleTreeOrderNumberComReqDto implementLoopWriteBackTargetCycleTreeOrderNumberComReqDto=new ImplementLoopWriteBackTargetCycleTreeOrderNumberComReqDto();
  if(reqDto!=null){
      implementLoopWriteBackTargetCycleTreeOrderNumberComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1805639_1_68514
implementLoopWriteBackTargetCycleTreeOrderNumberComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1805640_1_68514
implementLoopWriteBackTargetCycleTreeOrderNumberComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1805642_1_68514
implementLoopWriteBackTargetCycleTreeOrderNumberComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1805643_1_68514
    }
if(circulationCollectionsRes!=null){
      implementLoopWriteBackTargetCycleTreeOrderNumberComReqDto.setParentEvaObjTargetCycleId(circulationCollectionsRes.getParentEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1805641_1_68514
    }

    /*D3执行循环回写目标周期树排序(公共)[9595]   */
    Assert.isNull(implementLoopWriteBackTargetCycleTreeOrderNumberComReqDto.getEvaObjEntityId(),"D3执行刷全模板目标内容树排序-D3执行循环回写目标周期树排序(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(implementLoopWriteBackTargetCycleTreeOrderNumberComReqDto.getEvaObjTypeCode(),"D3执行刷全模板目标内容树排序-D3执行循环回写目标周期树排序(公共)-被评对象类型编码不能为空",false);
Assert.isNull(implementLoopWriteBackTargetCycleTreeOrderNumberComReqDto.getParentEvaObjTargetCycleId(),"D3执行刷全模板目标内容树排序-D3执行循环回写目标周期树排序(公共)-上级被评对象目标周期标识不能为空",false);
Assert.isNull(implementLoopWriteBackTargetCycleTreeOrderNumberComReqDto.getEvaluationTemplateId(),"D3执行刷全模板目标内容树排序-D3执行循环回写目标周期树排序(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(implementLoopWriteBackTargetCycleTreeOrderNumberComReqDto.getSpaceId(),"D3执行刷全模板目标内容树排序-D3执行循环回写目标周期树排序(公共)-创建于空间ID不能为空",false);
      implementLoopWriteBackTargetCycleTreeOrderNumberComRespDto = implementLoopWriteBackTargetCycleTreeOrderNumberCom(implementLoopWriteBackTargetCycleTreeOrderNumberComReqDto)/*vcase invoke 同服务,同domain*/;



    }
//ModelCode: circulationEnd
        }

      }
ImplementBrushTempTargetContTreeOrderNumRespDto retData = new ImplementBrushTempTargetContTreeOrderNumRespDto();





return retData;
  }
/**
   * D3执行回写目标周期树排序(公共)[9594]
   * gen by moon at 5/18/2024, 12:01:38 AM
   */
  @Trace(operationName = "D3执行回写目标周期树排序(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementWriteBackTargetCycleTreeOrderNumberComRespDto implementWriteBackTargetCycleTreeOrderNumberCom(ImplementWriteBackTargetCycleTreeOrderNumberComReqDto reqDto){


      //步骤0: M3执行第四接收字段（特殊方法） - implementFourthReceivingField
     //ModelCode: receptionService
        ImplementFourthReceivingFieldRespDto receptionServiceRes = null;
    ImplementFourthReceivingFieldReqDto receptionServiceReq=new ImplementFourthReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1805331_1
receptionServiceReq.setTargetTreeOrderNumber(reqDto.getTargetTreeOrderNumber());//SimpleFieldAssign//sourceId:1805337_1
receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1805335_1
receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1805353_1
    }

    /*M3接收入参字段[8259]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getTargetCycleContentId(),"D3执行回写目标周期树排序(公共)-M3接收入参字段-关联目标内容ID不能为空",false);
Assert.isNull(receptionServiceReq.getTargetTreeOrderNumber(),"D3执行回写目标周期树排序(公共)-M3接收入参字段-目标树排序不能为空",false);
Assert.isNull(receptionServiceReq.getEvaluationTemplateId(),"D3执行回写目标周期树排序(公共)-M3接收入参字段-冗余评价模板ID不能为空",false);
Assert.isNull(receptionServiceReq.getSpaceId(),"D3执行回写目标周期树排序(公共)-M3接收入参字段-创建于空间ID不能为空",false);
      receptionServiceRes = nbTargetContCom.implementFourthReceivingField(receptionServiceReq);




//步骤1: 3-3-09查目标周期（标识排序小到大）列表 - queryTargetCycleCodeOrderStoMaxList
     List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle =new ArrayList<>();
    QueryTargetCycleCodeOrderStoMaxListReq queryTargetCycleCodeOrderStoMaxListReq=new QueryTargetCycleCodeOrderStoMaxListReq();
  queryTargetCycleCodeOrderStoMaxListReq.setIsArchive("FALSE");//sourceId:1805351_1
if(reqDto!=null){
      queryTargetCycleCodeOrderStoMaxListReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1805345_1
queryTargetCycleCodeOrderStoMaxListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1805347_1
queryTargetCycleCodeOrderStoMaxListReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1805349_1
    }

    /*3-3-09查目标周期（标识排序小到大）列表[7584]   */
    Assert.isNull(queryTargetCycleCodeOrderStoMaxListReq.getTargetCycleContentId(),"D3执行回写目标周期树排序(公共)-3-3-09查目标周期（标识排序小到大）列表-关联目标内容ID不能为空",false);
Assert.isNull(queryTargetCycleCodeOrderStoMaxListReq.getEvaluationTemplateId(),"D3执行回写目标周期树排序(公共)-3-3-09查目标周期（标识排序小到大）列表-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetCycleCodeOrderStoMaxListReq.getIsArchive(),"D3执行回写目标周期树排序(公共)-3-3-09查目标周期（标识排序小到大）列表-是否存档不能为空",false);
Assert.isNull(queryTargetCycleCodeOrderStoMaxListReq.getSpaceId(),"D3执行回写目标周期树排序(公共)-3-3-09查目标周期（标识排序小到大）列表-创建于空间ID不能为空",false);
      listOmsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryTargetCycleCodeOrderStoMaxList(queryTargetCycleCodeOrderStoMaxListReq)/*vcase invoke 本地 method 方法调用;*/;




//步骤2: 3-3-09-01批量改被评对象目标周期 - batchUpdateEvaObjTargetCycle
     boolean bOOLEAN ;
    if(listOmsEvaluationObjectTargetCycle !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)&& listOmsEvaluationObjectTargetCycle.size()>0 ){
          List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle_2=new ArrayList<>();
  if(listOmsEvaluationObjectTargetCycle!= null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)&&  listOmsEvaluationObjectTargetCycle !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)){
      listOmsEvaluationObjectTargetCycle_2 = //objList-to-objLists
        listOmsEvaluationObjectTargetCycle.stream().map(item -> {
      OmsEvaluationObjectTargetCycle elm = new OmsEvaluationObjectTargetCycle();
      elm.setEvaObjTargetCycleId(item.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:363443_2
elm.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:363444_2
elm.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:363445_2
if(reqDto!=null){
      elm.setTargetTreeOrderNumber(reqDto.getTargetTreeOrderNumber());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:363447_2
    }
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:1805365_1
    }

    /*3-3-09-01批量改被评对象目标周期[2664]   */

      bOOLEAN = mOmsEvaluationObjectTargetCycleService.batchUpdateEvaObjTargetCycle(listOmsEvaluationObjectTargetCycle_2)/*vcase invoke 本地 method 方法调用;*/;



           }

ImplementWriteBackTargetCycleTreeOrderNumberComRespDto retData = new ImplementWriteBackTargetCycleTreeOrderNumberComRespDto();





return retData;
  }
/**
   * D3执行循环回写目标周期树排序(公共)[9595]
   * gen by moon at 5/17/2024, 2:19:38 AM
   */
  @Trace(operationName = "D3执行循环回写目标周期树排序(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementLoopWriteBackTargetCycleTreeOrderNumberComRespDto implementLoopWriteBackTargetCycleTreeOrderNumberCom(ImplementLoopWriteBackTargetCycleTreeOrderNumberComReqDto reqDto){


      //virtualUsage 3-3-09查询目标周期（内容排序从小到大）列表  68520
      List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle =new ArrayList<>();
    QueryTargetCycleByOrderNumFormSmallToLagListReq queryTargetCycleByOrderNumFormSmallToLagListReq=new QueryTargetCycleByOrderNumFormSmallToLagListReq();
  queryTargetCycleByOrderNumFormSmallToLagListReq.setIsParentCycle("TRUE");//sourceId:1805422_1_68520
queryTargetCycleByOrderNumFormSmallToLagListReq.setIsArchive("FALSE");//sourceId:1805424_1_68520
if(reqDto!=null){
      queryTargetCycleByOrderNumFormSmallToLagListReq.setParentEvaObjTargetCycleId(reqDto.getParentEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1805419_1_68520
queryTargetCycleByOrderNumFormSmallToLagListReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1805420_1_68520
queryTargetCycleByOrderNumFormSmallToLagListReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1805421_1_68520
queryTargetCycleByOrderNumFormSmallToLagListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1805423_1_68520
queryTargetCycleByOrderNumFormSmallToLagListReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1805425_1_68520
    }

    /*3-3-09查询目标周期（内容排序从小到大）列表[9593]   */
    Assert.isNull(queryTargetCycleByOrderNumFormSmallToLagListReq.getParentEvaObjTargetCycleId(),"D3执行循环回写目标周期树排序(公共)-3-3-09查询目标周期（内容排序从小到大）列表-上级被评对象目标周期标识不能为空",false);
Assert.isNull(queryTargetCycleByOrderNumFormSmallToLagListReq.getEvaObjEntityId(),"D3执行循环回写目标周期树排序(公共)-3-3-09查询目标周期（内容排序从小到大）列表-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryTargetCycleByOrderNumFormSmallToLagListReq.getEvaObjTypeCode(),"D3执行循环回写目标周期树排序(公共)-3-3-09查询目标周期（内容排序从小到大）列表-被评对象类型编码不能为空",false);
Assert.isNull(queryTargetCycleByOrderNumFormSmallToLagListReq.getIsParentCycle(),"D3执行循环回写目标周期树排序(公共)-3-3-09查询目标周期（内容排序从小到大）列表-是否父周期不能为空",false);
Assert.isNull(queryTargetCycleByOrderNumFormSmallToLagListReq.getEvaluationTemplateId(),"D3执行循环回写目标周期树排序(公共)-3-3-09查询目标周期（内容排序从小到大）列表-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetCycleByOrderNumFormSmallToLagListReq.getIsArchive(),"D3执行循环回写目标周期树排序(公共)-3-3-09查询目标周期（内容排序从小到大）列表-是否存档不能为空",false);
Assert.isNull(queryTargetCycleByOrderNumFormSmallToLagListReq.getSpaceId(),"D3执行循环回写目标周期树排序(公共)-3-3-09查询目标周期（内容排序从小到大）列表-创建于空间ID不能为空",false);
      listOmsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryTargetCycleByOrderNumFormSmallToLagList(queryTargetCycleByOrderNumFormSmallToLagListReq)/*vcase invoke 本地 method 方法调用;*/;



if((listOmsEvaluationObjectTargetCycle!= null&&  listOmsEvaluationObjectTargetCycle !=null && listOmsEvaluationObjectTargetCycle.size()>0)) {
        //if(3-3-09查询目标周期（内容排序从小到大）列表.被评对象目标周期列表数据集条数 大于 0)  68521

QueryEvaObjTargetCyclePlatformDetailComRespDto queryEvaObjTargetCyclePlatformDetailComRespDto = null;
    QueryEvaObjTargetCyclePlatformDetailComReqDto queryEvaObjTargetCyclePlatformDetailComReqDto=new QueryEvaObjTargetCyclePlatformDetailComReqDto();
  queryEvaObjTargetCyclePlatformDetailComReqDto.setIsParentCycle("TRUE");//sourceId:1805584_1_68524
queryEvaObjTargetCyclePlatformDetailComReqDto.setIsArchive("FALSE");//sourceId:1805585_1_68524
if(reqDto!=null){
      queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaObjTargetCycleCode(reqDto.getParentEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1805631_1_68524
queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1805582_1_68524
queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1805583_1_68524
queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1805586_1_68524
queryEvaObjTargetCyclePlatformDetailComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1805587_1_68524
    }

    /*D3查上级目标内容目标树排序[8528]   */
    Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getEvaObjTargetCycleCode(),"D3执行循环回写目标周期树排序(公共)-D3查上级目标内容目标树排序-被评对象目标周期标识不能为空",false);
Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getEvaObjEntityId(),"D3执行循环回写目标周期树排序(公共)-D3查上级目标内容目标树排序-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getEvaObjTypeCode(),"D3执行循环回写目标周期树排序(公共)-D3查上级目标内容目标树排序-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getIsParentCycle(),"D3执行循环回写目标周期树排序(公共)-D3查上级目标内容目标树排序-是否父周期不能为空",false);
Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getIsArchive(),"D3执行循环回写目标周期树排序(公共)-D3查上级目标内容目标树排序-是否存档不能为空",false);
Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getEvaluationTemplateId(),"D3执行循环回写目标周期树排序(公共)-D3查上级目标内容目标树排序-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getSpaceId(),"D3执行循环回写目标周期树排序(公共)-D3查上级目标内容目标树排序-创建于空间ID不能为空",false);
      queryEvaObjTargetCyclePlatformDetailComRespDto = targetCycleService.queryEvaObjTargetCyclePlatformDetailCom(queryEvaObjTargetCyclePlatformDetailComReqDto)/*vcase invoke isSameApp*/;



//ModelCode: circulationCollections
        for (OmsEvaluationObjectTargetCycle circulationCollectionsRes: listOmsEvaluationObjectTargetCycle){

ObtainOutPutCurrentTreeOrderNumberComRespDto obtainOutPutCurrentTreeOrderNumberComRespDto = null;
    if(queryEvaObjTargetCyclePlatformDetailComRespDto !=null){
          ObtainOutPutCurrentTreeOrderNumberComReqDto obtainOutPutCurrentTreeOrderNumberComReqDto=new ObtainOutPutCurrentTreeOrderNumberComReqDto();
  if(queryEvaObjTargetCyclePlatformDetailComRespDto!=null){
      obtainOutPutCurrentTreeOrderNumberComReqDto.setSuperiorsTreeOrderNumbeir(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetTreeOrderNumber());//SimpleFieldAssign//sourceId:1805622_1_68525
    }
if(circulationCollectionsRes!=null){
      obtainOutPutCurrentTreeOrderNumberComReqDto.setOrderNumber(circulationCollectionsRes.getRelativeOrderNumber());//SimpleFieldAssign//sourceId:1805623_1_68525
    }

    /*D2输出当前树排序值(公共)[9596] 通过上级树排序与当前排序，分析出当前树排序值。例如：上级树排序值1001，本级排序1，则本级树排序值为10011001  */
    Assert.isNull(obtainOutPutCurrentTreeOrderNumberComReqDto.getSuperiorsTreeOrderNumbeir(),"D3执行循环回写目标周期树排序(公共)-D2输出当前树排序值(公共)-上级树排序不能为空",false);
Assert.isNull(obtainOutPutCurrentTreeOrderNumberComReqDto.getOrderNumber(),"D3执行循环回写目标周期树排序(公共)-D2输出当前树排序值(公共)-排序不能为空",false);
      obtainOutPutCurrentTreeOrderNumberComRespDto = fwCompInterfaceModeClient.obtainOutPutCurrentTreeOrderNumberCom(obtainOutPutCurrentTreeOrderNumberComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
ImplementWriteBackTargetCycleTreeOrderNumberComRespDto implementWriteBackTargetCycleTreeOrderNumberComRespDto = null;
    if(obtainOutPutCurrentTreeOrderNumberComRespDto !=null){
          ImplementWriteBackTargetCycleTreeOrderNumberComReqDto implementWriteBackTargetCycleTreeOrderNumberComReqDto=new ImplementWriteBackTargetCycleTreeOrderNumberComReqDto();
  if(obtainOutPutCurrentTreeOrderNumberComRespDto!=null){
      implementWriteBackTargetCycleTreeOrderNumberComReqDto.setTargetTreeOrderNumber(obtainOutPutCurrentTreeOrderNumberComRespDto.getTreeOrderNumbeir());//SimpleFieldAssign//sourceId:1805508_1_68526
    }
if(circulationCollectionsRes!=null){
      implementWriteBackTargetCycleTreeOrderNumberComReqDto.setTargetCycleContentId(circulationCollectionsRes.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1805507_1_68526
    }
if(reqDto!=null){
      implementWriteBackTargetCycleTreeOrderNumberComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1805509_1_68526
implementWriteBackTargetCycleTreeOrderNumberComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1805510_1_68526
    }

    /*D3执行回写目标周期树排序(公共)[9594]   */
    Assert.isNull(implementWriteBackTargetCycleTreeOrderNumberComReqDto.getTargetTreeOrderNumber(),"D3执行循环回写目标周期树排序(公共)-D3执行回写目标周期树排序(公共)-目标树排序不能为空",false);
Assert.isNull(implementWriteBackTargetCycleTreeOrderNumberComReqDto.getTargetCycleContentId(),"D3执行循环回写目标周期树排序(公共)-D3执行回写目标周期树排序(公共)-关联目标内容ID不能为空",false);
Assert.isNull(implementWriteBackTargetCycleTreeOrderNumberComReqDto.getEvaluationTemplateId(),"D3执行循环回写目标周期树排序(公共)-D3执行回写目标周期树排序(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(implementWriteBackTargetCycleTreeOrderNumberComReqDto.getSpaceId(),"D3执行循环回写目标周期树排序(公共)-D3执行回写目标周期树排序(公共)-创建于空间ID不能为空",false);
      implementWriteBackTargetCycleTreeOrderNumberComRespDto = implementWriteBackTargetCycleTreeOrderNumberCom(implementWriteBackTargetCycleTreeOrderNumberComReqDto)/*vcase invoke 同服务,同domain*/;



           }
//ModelCode: circulationEnd
        }

      }
ImplementLoopWriteBackTargetCycleTreeOrderNumberComRespDto retData = new ImplementLoopWriteBackTargetCycleTreeOrderNumberComRespDto();





return retData;
  }
/**
   * D3查询目标内容属性公共信息(公共)[10084]
   * gen by moon at 8/8/2024, 10:03:48 PM
   */
  @Trace(operationName = "D3查询目标内容属性公共信息(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryTargetContNatureComInfoDetailComRespDto queryTargetContNatureComInfoDetailCom(QueryTargetContNatureComInfoDetailComReqDto reqDto){


      ImplementAcceptFieldRespDto receptionServiceRes_1 =null;
if((reqDto!= null&&  reqDto.getTableTypeCode() !=null && reqDto.getTableTypeCode().equals("OMS_TARGET_CATEGORY"))) {
        //if(D3查询目标内容属性公共信息(公共).内容表类型编码 等于 目标分类表)  72061

OmsTargetCategory omsTargetCategory = null;
    QueryTargetCatDetailReq queryTargetCatDetailReq=new QueryTargetCatDetailReq();
  if(reqDto!=null){
      queryTargetCatDetailReq.setTargetCategoryId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1965026_1_72063
queryTargetCatDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1965027_1_72063
    }

    /*3-3-02查目标分类详情[2595]   */
    Assert.isNull(queryTargetCatDetailReq.getTargetCategoryId(),"D3查询目标内容属性公共信息(公共)-3-3-02查目标分类详情-目标分类ID不能为空",false);
Assert.isNull(queryTargetCatDetailReq.getEvaluationTemplateId(),"D3查询目标内容属性公共信息(公共)-3-3-02查目标分类详情-冗余评价模板ID不能为空",false);
      omsTargetCategory = mOmsTargetCategoryService.queryTargetCatDetail(queryTargetCatDetailReq)/*vcase invoke 本地 method 方法调用;*/;



//ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes = null;
    if(omsTargetCategory !=null){
          ImplementAcceptFieldReqDto receptionServiceReq=new ImplementAcceptFieldReqDto();
  if(omsTargetCategory!=null){
      receptionServiceReq.setIsLast(omsTargetCategory.getIsLast());//SimpleFieldAssign//sourceId:1965046_1_72065
receptionServiceReq.setLevelNumber(omsTargetCategory.getLevelNumber());//SimpleFieldAssign//sourceId:1965047_1_72065
    }

    /*M3接收内容属性信息出参[6100]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getIsLast(),"D3查询目标内容属性公共信息(公共)-M3接收内容属性信息出参-是否末级不能为空",false);
Assert.isNull(receptionServiceReq.getLevelNumber(),"D3查询目标内容属性公共信息(公共)-M3接收内容属性信息出参-层级不能为空",false);
      receptionServiceRes = nbTargetContCom.implementAcceptField(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
           }
      }
else if((reqDto!= null&&  reqDto.getTableTypeCode() !=null && reqDto.getTableTypeCode().equals("OMS_TARGET_OBJECTIVE"))){
       //elseif(D3查询目标内容属性公共信息(公共).内容表类型编码 等于 指标表)  72062

OmsTargetObjective omsTargetObjective = null;
    QueryTargetObjDetailReq queryTargetObjDetailReq=new QueryTargetObjDetailReq();
  if(reqDto!=null){
      queryTargetObjDetailReq.setObjectiveId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1965033_1_72064
queryTargetObjDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1965034_1_72064
    }

    /*3-3-03查指标详情[2697]   */
    Assert.isNull(queryTargetObjDetailReq.getObjectiveId(),"D3查询目标内容属性公共信息(公共)-3-3-03查指标详情-指标ID不能为空",false);
Assert.isNull(queryTargetObjDetailReq.getEvaluationTemplateId(),"D3查询目标内容属性公共信息(公共)-3-3-03查指标详情-冗余评价模板ID不能为空",false);
      omsTargetObjective = mOmsTargetObjectiveService.queryTargetObjDetail(queryTargetObjDetailReq)/*vcase invoke 本地 method 方法调用;*/;



//ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes_2 = null;
    if(omsTargetObjective !=null){
          ImplementAcceptFieldReqDto receptionServiceReq_1=new ImplementAcceptFieldReqDto();
  if(omsTargetObjective!=null){
      receptionServiceReq_1.setIsLast(omsTargetObjective.getIsLastObjective());//SimpleFieldAssign//sourceId:1965046_1_72066
receptionServiceReq_1.setLevelNumber(omsTargetObjective.getLevelNumber());//SimpleFieldAssign//sourceId:1965047_1_72066
    }

    /*M3接收内容属性信息出参[6100]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getIsLast(),"D3查询目标内容属性公共信息(公共)-M3接收内容属性信息出参-是否末级不能为空",false);
Assert.isNull(receptionServiceReq_1.getLevelNumber(),"D3查询目标内容属性公共信息(公共)-M3接收内容属性信息出参-层级不能为空",false);
      receptionServiceRes_2 = nbTargetContCom.implementAcceptField(receptionServiceReq_1);


      receptionServiceRes_1 = receptionServiceRes_2;
           }
    }
QueryTargetContNatureComInfoDetailComRespDto retData = new QueryTargetContNatureComInfoDetailComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setIsLast(receptionServiceRes_1.getIsLast());//SimpleFieldAssign//sourceId:1965052_1
retData.setLevelNumber(receptionServiceRes_1.getLevelNumber());//SimpleFieldAssign//sourceId:1965053_1
    }




return retData;
  }
/**
   * D3查询目标内容面包屑列表[10088]
   * gen by moon at 8/9/2024, 3:54:56 PM
   */
  @Trace(operationName = "D3查询目标内容面包屑列表")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryTargetContCrumbsListRespDto queryTargetContCrumbsList(QueryTargetContCrumbsListReqDto reqDto){


      QueryAncestorTargetCycleListComRespDto queryAncestorTargetCycleListComRespDto_1 =null;
//步骤0: M3接收外部字段(特殊方法） - obtainReceiveOutField
     //ModelCode: receptionService
        ObtainReceiveOutFieldRespDto receptionServiceRes = null;
    ObtainReceiveOutFieldReqDto receptionServiceReq=new ObtainReceiveOutFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1966730_1
receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1966726_1
    }

    /*M3接收入参字段[4608]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getEvaObjTargetCycleId(),"D3查询目标内容面包屑列表-M3接收入参字段-被评对象目标周期ID不能为空",false);
Assert.isNull(receptionServiceReq.getEvaluationTemplateId(),"D3查询目标内容面包屑列表-M3接收入参字段-冗余评价模板ID不能为空",false);
      receptionServiceRes = nbTargetContCom.obtainReceiveOutField(receptionServiceReq);




//步骤1: D3-查询被评对象目标周期平台详情(公共) - queryEvaObjTargetCyclePlatformDetailCom
     QueryEvaObjTargetCyclePlatformDetailComRespDto queryEvaObjTargetCyclePlatformDetailComRespDto = null;
    QueryEvaObjTargetCyclePlatformDetailComReqDto queryEvaObjTargetCyclePlatformDetailComReqDto=new QueryEvaObjTargetCyclePlatformDetailComReqDto();
  if(reqDto!=null){
      queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1966801_1
queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1966802_1
    }

    /*D3-查询被评对象目标周期平台详情(公共)[8528]   */
    Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getEvaObjTargetCycleId(),"D3查询目标内容面包屑列表-D3-查询被评对象目标周期平台详情(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getEvaluationTemplateId(),"D3查询目标内容面包屑列表-D3-查询被评对象目标周期平台详情(公共)-冗余评价模板ID不能为空",false);
      queryEvaObjTargetCyclePlatformDetailComRespDto = targetCycleService.queryEvaObjTargetCyclePlatformDetailCom(queryEvaObjTargetCyclePlatformDetailComReqDto)/*vcase invoke isSameApp*/;




//步骤2: D3查祖先目标周期列表(公共) - queryAncestorTargetCycleListCom
     QueryAncestorTargetCycleListComRespDto queryAncestorTargetCycleListComRespDto = null;
    if(queryEvaObjTargetCyclePlatformDetailComRespDto !=null){
          QueryAncestorTargetCycleListComReqDto queryAncestorTargetCycleListComReqDto=new QueryAncestorTargetCycleListComReqDto();
  if(queryEvaObjTargetCyclePlatformDetailComRespDto!=null){
      queryAncestorTargetCycleListComReqDto.setComCode(queryEvaObjTargetCyclePlatformDetailComRespDto.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:1966373_1
queryAncestorTargetCycleListComReqDto.setEvaObjEntityId(queryEvaObjTargetCyclePlatformDetailComRespDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1966374_1
queryAncestorTargetCycleListComReqDto.setEvaObjTypeCode(queryEvaObjTargetCyclePlatformDetailComRespDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1966375_1
    }
if(reqDto!=null){
      queryAncestorTargetCycleListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1966376_1
    }

    /*D3查祖先目标周期列表(公共)[6312]   */
    Assert.isNull(queryAncestorTargetCycleListComReqDto.getComCode(),"D3查询目标内容面包屑列表-D3查祖先目标周期列表(公共)-通用编码标识不能为空",false);
Assert.isNull(queryAncestorTargetCycleListComReqDto.getEvaObjEntityId(),"D3查询目标内容面包屑列表-D3查祖先目标周期列表(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryAncestorTargetCycleListComReqDto.getEvaObjTypeCode(),"D3查询目标内容面包屑列表-D3查祖先目标周期列表(公共)-被评对象类型编码不能为空",false);
Assert.isNull(queryAncestorTargetCycleListComReqDto.getEvaluationTemplateId(),"D3查询目标内容面包屑列表-D3查祖先目标周期列表(公共)-冗余评价模板ID不能为空",false);
      queryAncestorTargetCycleListComRespDto = targetContentService.queryAncestorTargetCycleListCom(queryAncestorTargetCycleListComReqDto)/*vcase invoke isSameApp*/;


      queryAncestorTargetCycleListComRespDto_1 = queryAncestorTargetCycleListComRespDto;
           }

QueryTargetContCrumbsListRespDto retData = new QueryTargetContCrumbsListRespDto();
  if(queryAncestorTargetCycleListComRespDto_1!=null){
      retData.setEvaObjTargetCycleList(queryAncestorTargetCycleListComRespDto_1.getEvaObjTargetCycleList().stream().map(item -> BeanUtil.toBean(item, EvaObjTargetCycleDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1966803_1
    }




return retData;
  }
/**
   * D3批量查目标周期By内容ID（时间范围切）(公共)[10245]
   * gen by moon at 9/29/2024, 10:05:08 PM
   */
  @Trace(operationName = "D3批量查目标周期By内容ID（时间范围切）(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementBatchQueryByContIdTimeSectionComRespDto implementBatchQueryByContIdTimeSectionCom(ImplementBatchQueryByContIdTimeSectionComReqDto reqDto){


      List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle_1 =new ArrayList<>();
//步骤0: 3-3-09执行批量查目标周期By内容ID（时间范围切） - implementBatchQueryByContIdTimeSection
     List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle =new ArrayList<>();
    ImplementBatchQueryByContIdTimeSectionReq implementBatchQueryByContIdTimeSectionReq=new ImplementBatchQueryByContIdTimeSectionReq();
  if(reqDto!=null){
      implementBatchQueryByContIdTimeSectionReq.setEvaObjTargetCycleList(reqDto.getEvaObjTargetCycleList());//list-field-assign//sourceId:2011077_1
implementBatchQueryByContIdTimeSectionReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:2011078_1
implementBatchQueryByContIdTimeSectionReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:2012118_1
implementBatchQueryByContIdTimeSectionReq.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:2011093_1
implementBatchQueryByContIdTimeSectionReq.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:2011094_1
implementBatchQueryByContIdTimeSectionReq.setIsParentCycle(reqDto.getIsParentCycle());//SimpleFieldAssign//sourceId:2011079_1
implementBatchQueryByContIdTimeSectionReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2011080_1
implementBatchQueryByContIdTimeSectionReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:2011081_1
implementBatchQueryByContIdTimeSectionReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:2011082_1
    }

    /*3-3-09执行批量查目标周期By内容ID（时间范围切）[10244]   */

      listOmsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.implementBatchQueryByContIdTimeSection(implementBatchQueryByContIdTimeSectionReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsEvaluationObjectTargetCycle_1 = listOmsEvaluationObjectTargetCycle;

ImplementBatchQueryByContIdTimeSectionComRespDto retData = new ImplementBatchQueryByContIdTimeSectionComRespDto();
  retData.setEvaObjTargetCycleList(listOmsEvaluationObjectTargetCycle_1.stream().map(item -> BeanUtil.toBean(item, EvaObjTargetCycleDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2011090_1




return retData;
  }
/**
   * D3查询规划数据导出内容范围列表(公共)[10479]
   * gen by moon at 5/8/2025, 9:27:40 PM
   */
  @Trace(operationName = "D3查询规划数据导出内容范围列表(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryPlanningDataExportRangeListComRespDto queryPlanningDataExportRangeListCom(QueryPlanningDataExportRangeListComReqDto reqDto){


      ImplementParentSubMidCycleTypeTurnSingleFieldComRespDto implementParentSubMidCycleTypeTurnSingleFieldComRespDto_1 =null;
QueryConOfEvaTempleteListComRespDto queryConOfEvaTempleteListComRespDto_1 =null;
List<OmsEvaluationTemplate> listOmsEvaluationTemplate_1 =new ArrayList<>();
List<OmsTargetCategory> listOmsTargetCategory_1 =new ArrayList<>();
List<OmsTargetCategory> listOmsTargetCategory_3 =new ArrayList<>();
BatchQueryVirtualCircleByContComRespDto batchQueryVirtualCircleByContComRespDto_1 =null;
//virtualUsage D3执行父子中周期类型转单字段(公共)  74028
      ImplementParentSubMidCycleTypeTurnSingleFieldComRespDto implementParentSubMidCycleTypeTurnSingleFieldComRespDto = null;
    ImplementParentSubMidCycleTypeTurnSingleFieldComReqDto implementParentSubMidCycleTypeTurnSingleFieldComReqDto=new ImplementParentSubMidCycleTypeTurnSingleFieldComReqDto();
  if(reqDto!=null){
      implementParentSubMidCycleTypeTurnSingleFieldComReqDto.setPeriodId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:2038958_1_74028
implementParentSubMidCycleTypeTurnSingleFieldComReqDto.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:2038956_1_74028
    }

    /*D3执行父子中周期类型转单字段(公共)[9364]   */
    Assert.isNull(implementParentSubMidCycleTypeTurnSingleFieldComReqDto.getParentSubMidCycleType(),"D3查询规划数据导出内容范围列表(公共)-D3执行父子中周期类型转单字段(公共)-父子中周期类型不能为空",false);
      implementParentSubMidCycleTypeTurnSingleFieldComRespDto = targetCalcService.implementParentSubMidCycleTypeTurnSingleFieldCom(implementParentSubMidCycleTypeTurnSingleFieldComReqDto)/*vcase invoke isSameApp*/;


      implementParentSubMidCycleTypeTurnSingleFieldComRespDto_1 = implementParentSubMidCycleTypeTurnSingleFieldComRespDto;
//virtualUsage D3查询评价模板下内容列表(公共)  74027
      QueryConOfEvaTempleteListComRespDto queryConOfEvaTempleteListComRespDto = null;
    if(implementParentSubMidCycleTypeTurnSingleFieldComRespDto !=null){
          QueryConOfEvaTempleteListComReqDto queryConOfEvaTempleteListComReqDto=new QueryConOfEvaTempleteListComReqDto();
  if(implementParentSubMidCycleTypeTurnSingleFieldComRespDto!=null){
      queryConOfEvaTempleteListComReqDto.setCycleId(implementParentSubMidCycleTypeTurnSingleFieldComRespDto.getPeriodId());//SimpleFieldAssign//sourceId:2047073_1_74027
queryConOfEvaTempleteListComReqDto.setIsParentCycle(implementParentSubMidCycleTypeTurnSingleFieldComRespDto.getIsParentCycle());//SimpleFieldAssign//sourceId:2047074_1_74027
queryConOfEvaTempleteListComReqDto.setIsMetaphase(implementParentSubMidCycleTypeTurnSingleFieldComRespDto.getIsMetaphase());//SimpleFieldAssign//sourceId:2047075_1_74027
queryConOfEvaTempleteListComReqDto.setIsSubCycle(implementParentSubMidCycleTypeTurnSingleFieldComRespDto.getIsSubCycle());//SimpleFieldAssign//sourceId:2047076_1_74027
    }
if(reqDto!=null){
      queryConOfEvaTempleteListComReqDto.setLevelNumber(reqDto.getLevelNumber());//SimpleFieldAssign//sourceId:2047077_1_74027
queryConOfEvaTempleteListComReqDto.setIsLastObjective(reqDto.getIsLastObjective());//SimpleFieldAssign//sourceId:2047078_1_74027
queryConOfEvaTempleteListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2047079_1_74027
queryConOfEvaTempleteListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:2047080_1_74027
    }

    /*D3查询评价模板下内容列表(公共)[10526]   */
    Assert.isNull(queryConOfEvaTempleteListComReqDto.getEvaluationTemplateId(),"D3查询规划数据导出内容范围列表(公共)-D3查询评价模板下内容列表(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(queryConOfEvaTempleteListComReqDto.getSpaceId(),"D3查询规划数据导出内容范围列表(公共)-D3查询评价模板下内容列表(公共)-创建于空间ID不能为空",false);
      queryConOfEvaTempleteListComRespDto = dashboardTargetContentService.queryConOfEvaTempleteListCom(queryConOfEvaTempleteListComReqDto)/*vcase invoke isSameApp*/;


      queryConOfEvaTempleteListComRespDto_1 = queryConOfEvaTempleteListComRespDto;
           }
if((queryConOfEvaTempleteListComRespDto!= null&&  queryConOfEvaTempleteListComRespDto.getEvaObjTargetCycleList() !=null && queryConOfEvaTempleteListComRespDto.getEvaObjTargetCycleList().size()>0)) {
        //if(D3查询评价模板下内容列表(公共).被评对象目标周期列表数据集条数 大于 0)  73836

List<OmsEvaluationTemplate> listOmsEvaluationTemplate =new ArrayList<>();
    if(queryConOfEvaTempleteListComRespDto !=null){
          BatchQueryEvaTempReq batchQueryEvaTempReq=new BatchQueryEvaTempReq();
  batchQueryEvaTempReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2038438_1_73839
if(queryConOfEvaTempleteListComRespDto!= null&&  queryConOfEvaTempleteListComRespDto.getEvaObjTargetCycleList() !=null&& !CollectionUtil.isEmpty(queryConOfEvaTempleteListComRespDto.getEvaObjTargetCycleList())){
      batchQueryEvaTempReq.setEvalTempList(queryConOfEvaTempleteListComRespDto.getEvaObjTargetCycleList().stream().map(item->item.getEvaluationTemplateId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:2038435_1_73839
    }

    /*3-2-02批量查询评价模板[3075]   */
    Assert.isNull(batchQueryEvaTempReq.getSubjectLifeCycle(),"D3查询规划数据导出内容范围列表(公共)-3-2-02批量查询评价模板-主体生命周期不能为空",false);
      listOmsEvaluationTemplate = mOmsEvaluationTemplateService.batchQueryEvaTemp(batchQueryEvaTempReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsEvaluationTemplate_1 = listOmsEvaluationTemplate;
           }
List<OmsTargetCategory> listOmsTargetCategory =new ArrayList<>();
    if(queryConOfEvaTempleteListComRespDto !=null){
          BatchQueryTargetCatReq batchQueryTargetCatReq=new BatchQueryTargetCatReq();
  batchQueryTargetCatReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2038420_1_73837
if(queryConOfEvaTempleteListComRespDto!= null&&  queryConOfEvaTempleteListComRespDto.getEvaObjTargetCycleList() !=null&& !CollectionUtil.isEmpty(queryConOfEvaTempleteListComRespDto.getEvaObjTargetCycleList())){
      batchQueryTargetCatReq.setSetConstructionTaskList(queryConOfEvaTempleteListComRespDto.getEvaObjTargetCycleList().stream().map(item->item.getCorrelationLastTargetCatId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:2038419_1_73837
    }
if(reqDto!=null){
      batchQueryTargetCatReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2038426_1_73837
    }

    /*3-3-02批量查目标分类列表（查末级目标分类）[2254]   */
    Assert.isNull(batchQueryTargetCatReq.getEvaluationTemplateId(),"D3查询规划数据导出内容范围列表(公共)-3-3-02批量查目标分类列表（查末级目标分类）-冗余评价模板ID不能为空",false);
Assert.isNull(batchQueryTargetCatReq.getSubjectLifeCycle(),"D3查询规划数据导出内容范围列表(公共)-3-3-02批量查目标分类列表（查末级目标分类）-主体生命周期不能为空",false);
      listOmsTargetCategory = mOmsTargetCategoryService.batchQueryTargetCat(batchQueryTargetCatReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsTargetCategory_1 = listOmsTargetCategory;
           }
List<OmsTargetCategory> listOmsTargetCategory_2 =new ArrayList<>();
    if(queryConOfEvaTempleteListComRespDto !=null){
          BatchQueryTargetCatReq batchQueryTargetCatReq_1=new BatchQueryTargetCatReq();
  batchQueryTargetCatReq_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2038428_1_73838
if(queryConOfEvaTempleteListComRespDto!= null&&  queryConOfEvaTempleteListComRespDto.getEvaObjTargetCycleList() !=null&& !CollectionUtil.isEmpty(queryConOfEvaTempleteListComRespDto.getEvaObjTargetCycleList())){
      batchQueryTargetCatReq_1.setSetConstructionTaskList(queryConOfEvaTempleteListComRespDto.getEvaObjTargetCycleList().stream().map(item->item.getRootTargetCategoryId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:2038427_1_73838
    }
if(reqDto!=null){
      batchQueryTargetCatReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2038434_1_73838
    }

    /*3-3-02批量查目标分类列表（查一级目标分类）[2254]   */
    Assert.isNull(batchQueryTargetCatReq_1.getEvaluationTemplateId(),"D3查询规划数据导出内容范围列表(公共)-3-3-02批量查目标分类列表（查一级目标分类）-冗余评价模板ID不能为空",false);
Assert.isNull(batchQueryTargetCatReq_1.getSubjectLifeCycle(),"D3查询规划数据导出内容范围列表(公共)-3-3-02批量查目标分类列表（查一级目标分类）-主体生命周期不能为空",false);
      listOmsTargetCategory_2 = mOmsTargetCategoryService.batchQueryTargetCat(batchQueryTargetCatReq_1)/*vcase invoke 本地 method 方法调用;*/;


      listOmsTargetCategory_3 = listOmsTargetCategory_2;
           }
BatchQueryVirtualCircleByContComRespDto batchQueryVirtualCircleByContComRespDto = null;
    if(queryConOfEvaTempleteListComRespDto !=null){
          BatchQueryVirtualCircleByContComReqDto batchQueryVirtualCircleByContComReqDto=new BatchQueryVirtualCircleByContComReqDto();
  if(queryConOfEvaTempleteListComRespDto!= null&&  queryConOfEvaTempleteListComRespDto.getEvaObjTargetCycleList() !=null&& !CollectionUtil.isEmpty(queryConOfEvaTempleteListComRespDto.getEvaObjTargetCycleList())){
      batchQueryVirtualCircleByContComReqDto.setTargetContentList(queryConOfEvaTempleteListComRespDto.getEvaObjTargetCycleList().stream().map(item->item.getTargetCycleContentId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:2038448_1_73843
    }

    /*D3批量查询虚拟圈子By内容(公共)[10142]   */

      batchQueryVirtualCircleByContComRespDto = virtualOrgService.batchQueryVirtualCircleByContCom(batchQueryVirtualCircleByContComReqDto)/*vcase invoke isSameApp*/;


      batchQueryVirtualCircleByContComRespDto_1 = batchQueryVirtualCircleByContComRespDto;
           }
      }
QueryPlanningDataExportRangeListComRespDto retData = new QueryPlanningDataExportRangeListComRespDto();
  //数据集融合  MoreListToOneSource
        if(queryConOfEvaTempleteListComRespDto_1!= null && !CollectionUtil.isEmpty(queryConOfEvaTempleteListComRespDto_1.getEvaObjTargetCycleList()) ){
          for (EvaObjTargetCycleDto evaObjTargetCycleDto : queryConOfEvaTempleteListComRespDto_1.getEvaObjTargetCycleList()) {
              PlanningExportDetailDto retElm = new PlanningExportDetailDto();
             if(queryConOfEvaTempleteListComRespDto_1!=null){
      retElm.setTargetCycleContentId(evaObjTargetCycleDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:434474_2
retElm.setEvaObjTargetCycleId(evaObjTargetCycleDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:434477_2
retElm.setObjectiveShortName(evaObjTargetCycleDto.getObjectiveShortName());//SimpleFieldAssign//sourceId:434475_2
    }
              retData.getPlanningExportDetailList().add(retElm);
               if(listOmsEvaluationTemplate_1!= null&& !CollectionUtil.isEmpty(listOmsEvaluationTemplate_1)){
          for (OmsEvaluationTemplate omsEvaluationTemplate : listOmsEvaluationTemplate_1) {
                if (omsEvaluationTemplate.getEvaluationTemplateId().equals(evaObjTargetCycleDto.getEvaluationTemplateId())) {
                 retElm.setEvaluationTempName(omsEvaluationTemplate.getEvaluationTempName());//SimpleFieldAssign//sourceId:431107_2
                }
            }
          }

 if(listOmsTargetCategory_3!= null&& !CollectionUtil.isEmpty(listOmsTargetCategory_3)){
          for (OmsTargetCategory omsTargetCategory : listOmsTargetCategory_3) {
                if (omsTargetCategory.getTargetCategoryId().equals(evaObjTargetCycleDto.getRootTargetCategoryId())) {
                 retElm.setRootTargetCategoryName(omsTargetCategory.getTargetCategoryName());//SimpleFieldAssign//sourceId:431106_2
                }
            }
          }

 if(listOmsTargetCategory_1!= null&& !CollectionUtil.isEmpty(listOmsTargetCategory_1)){
          for (OmsTargetCategory omsTargetCategory : listOmsTargetCategory_1) {
                if (omsTargetCategory.getTargetCategoryId().equals(evaObjTargetCycleDto.getCorrelationLastTargetCatId())) {
                 retElm.setLastTargetCategoryName(omsTargetCategory.getTargetCategoryName());//SimpleFieldAssign//sourceId:431105_2
                }
            }
          }

 if(batchQueryVirtualCircleByContComRespDto_1!= null){
          for (TargetContentDto targetContentDto : batchQueryVirtualCircleByContComRespDto_1.getTargetContentList()) {
                if (targetContentDto.getEntityId().equals(evaObjTargetCycleDto.getTargetCycleContentId())) {
                 if(batchQueryVirtualCircleByContComRespDto_1!=null){
      retElm.setDeptId(targetContentDto.getDeptId());//SimpleFieldAssign//sourceId:431108_2
retElm.setPersonLiableInductionRecordId(targetContentDto.getPersonLiableInductionRecordId());//SimpleFieldAssign//sourceId:431109_2
retElm.setDirectorInductionRecordId(targetContentDto.getDirectorInductionRecordId());//SimpleFieldAssign//sourceId:431110_2
    }
                }
            }
          }

          }
        }//sourceId:2038450_1
if(implementParentSubMidCycleTypeTurnSingleFieldComRespDto_1!=null){
      retData.setPeriodId(implementParentSubMidCycleTypeTurnSingleFieldComRespDto_1.getPeriodId());//SimpleFieldAssign//sourceId:2038994_1
    }




return retData;
  }
/**
   * D3查询规划数据导出内容明细列表(公共)[10480]
   * gen by moon at 1/1/2025, 6:30:11 PM
   */
  @Trace(operationName = "D3查询规划数据导出内容明细列表(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryPlanningDataExportDetailListComRespDto queryPlanningDataExportDetailListCom(QueryPlanningDataExportDetailListComReqDto reqDto){


      QueryPlanningDataExportRangeListComRespDto queryPlanningDataExportRangeListComRespDto_1 =null;
BatchQueryDeptComRespDto batchQueryDeptComRespDto_1 =null;
BatchQueryInductionRecordListComRespDto batchQueryInductionRecordListComRespDto_1 =null;
BatchQueryInductionRecordListComRespDto batchQueryInductionRecordListComRespDto_3 =null;
List<OmsEvaObjTargetCycleOset> listOmsEvaObjTargetCycleOset_1 =new ArrayList<>();
QueryHighMidBaseWorkCycleDataListComRespDto queryHighMidBaseWorkCycleDataListComRespDto_1 =null;
//virtualUsage D3查询规划数据导出内容范围列表(公共)  73844
      QueryPlanningDataExportRangeListComRespDto queryPlanningDataExportRangeListComRespDto = null;
    QueryPlanningDataExportRangeListComReqDto queryPlanningDataExportRangeListComReqDto=new QueryPlanningDataExportRangeListComReqDto();
  queryPlanningDataExportRangeListComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2038904_1_73844
if(reqDto!=null){
      queryPlanningDataExportRangeListComReqDto.setLevelNumber(reqDto.getLevelNumber());//SimpleFieldAssign//sourceId:2038901_1_73844
queryPlanningDataExportRangeListComReqDto.setIsLastObjective(reqDto.getIsLastObjective());//SimpleFieldAssign//sourceId:2038902_1_73844
queryPlanningDataExportRangeListComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:2038981_1_73844
queryPlanningDataExportRangeListComReqDto.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:2038982_1_73844
queryPlanningDataExportRangeListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2038903_1_73844
    }

    /*D3查询规划数据导出内容范围列表(公共)[10479]   */
    Assert.isNull(queryPlanningDataExportRangeListComReqDto.getCycleId(),"D3查询规划数据导出内容明细列表(公共)-D3查询规划数据导出内容范围列表(公共)-归属周期ID不能为空",false);
Assert.isNull(queryPlanningDataExportRangeListComReqDto.getParentSubMidCycleType(),"D3查询规划数据导出内容明细列表(公共)-D3查询规划数据导出内容范围列表(公共)-父子中周期类型不能为空",false);
Assert.isNull(queryPlanningDataExportRangeListComReqDto.getEvaluationTemplateId(),"D3查询规划数据导出内容明细列表(公共)-D3查询规划数据导出内容范围列表(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(queryPlanningDataExportRangeListComReqDto.getSpaceId(),"D3查询规划数据导出内容明细列表(公共)-D3查询规划数据导出内容范围列表(公共)-创建于空间ID不能为空",false);
      queryPlanningDataExportRangeListComRespDto = queryPlanningDataExportRangeListCom(queryPlanningDataExportRangeListComReqDto)/*vcase invoke 同服务,同domain*/;


      queryPlanningDataExportRangeListComRespDto_1 = queryPlanningDataExportRangeListComRespDto;
if((queryPlanningDataExportRangeListComRespDto!= null&&  queryPlanningDataExportRangeListComRespDto.getPlanningExportDetailList() !=null && queryPlanningDataExportRangeListComRespDto.getPlanningExportDetailList().size()>0)) {
        //if(D3查询规划数据导出内容范围列表(公共).规划数据导出明细列表数据集条数 大于 0)  73845

BatchQueryDeptComRespDto batchQueryDeptComRespDto = null;
    if(queryPlanningDataExportRangeListComRespDto !=null){
          BatchQueryDeptComReqDto batchQueryDeptComReqDto=new BatchQueryDeptComReqDto();
  batchQueryDeptComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2038907_1_73846
if(queryPlanningDataExportRangeListComRespDto!= null&&  queryPlanningDataExportRangeListComRespDto.getPlanningExportDetailList() !=null&& !CollectionUtil.isEmpty(queryPlanningDataExportRangeListComRespDto.getPlanningExportDetailList())){
      batchQueryDeptComReqDto.setDeptList(queryPlanningDataExportRangeListComRespDto.getPlanningExportDetailList().stream().map(item->item.getDeptId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:2038906_1_73846
    }

    /*D1批量查询部门(公共)[7511]   */
    Assert.isNull(batchQueryDeptComReqDto.getSubjectLifeCycle(),"D3查询规划数据导出内容明细列表(公共)-D1批量查询部门(公共)-主体生命周期不能为空",false);
      batchQueryDeptComRespDto = fwBaseOrgClient.batchQueryDeptCom(batchQueryDeptComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      batchQueryDeptComRespDto_1 = batchQueryDeptComRespDto;
           }
BatchQueryInductionRecordListComRespDto batchQueryInductionRecordListComRespDto = null;
    if(queryPlanningDataExportRangeListComRespDto !=null){
          BatchQueryInductionRecordListComReqDto batchQueryInductionRecordListComReqDto=new BatchQueryInductionRecordListComReqDto();
  if(queryPlanningDataExportRangeListComRespDto!= null&&  queryPlanningDataExportRangeListComRespDto.getPlanningExportDetailList() !=null&& !CollectionUtil.isEmpty(queryPlanningDataExportRangeListComRespDto.getPlanningExportDetailList())){
      batchQueryInductionRecordListComReqDto.setPerOrgInductionRecordList(queryPlanningDataExportRangeListComRespDto.getPlanningExportDetailList().stream().map(item->String.valueOf(item.getPersonLiableInductionRecordId()))
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:2038909_1_73847
    }

    /*D1-3批量查责任人就职记录列表（公共）[602]   */

      batchQueryInductionRecordListComRespDto = fwBaseInductionRecordClient.batchQueryInductionRecordListCom(batchQueryInductionRecordListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      batchQueryInductionRecordListComRespDto_1 = batchQueryInductionRecordListComRespDto;
           }
BatchQueryInductionRecordListComRespDto batchQueryInductionRecordListComRespDto_2 = null;
    if(queryPlanningDataExportRangeListComRespDto !=null){
          BatchQueryInductionRecordListComReqDto batchQueryInductionRecordListComReqDto_1=new BatchQueryInductionRecordListComReqDto();
  if(queryPlanningDataExportRangeListComRespDto!= null&&  queryPlanningDataExportRangeListComRespDto.getPlanningExportDetailList() !=null&& !CollectionUtil.isEmpty(queryPlanningDataExportRangeListComRespDto.getPlanningExportDetailList())){
      batchQueryInductionRecordListComReqDto_1.setPerOrgInductionRecordList(queryPlanningDataExportRangeListComRespDto.getPlanningExportDetailList().stream().map(item->String.valueOf(item.getDirectorInductionRecordId()))
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:2038912_1_73848
    }

    /*D1-3批量查询主管就职记录列表（公共）[602]   */

      batchQueryInductionRecordListComRespDto_2 = fwBaseInductionRecordClient.batchQueryInductionRecordListCom(batchQueryInductionRecordListComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


      batchQueryInductionRecordListComRespDto_3 = batchQueryInductionRecordListComRespDto_2;
           }
List<OmsEvaObjTargetCycleOset> listOmsEvaObjTargetCycleOset =new ArrayList<>();
    if(queryPlanningDataExportRangeListComRespDto !=null){
          BatchQueryEvaObjTargetCycleTargetReq batchQueryEvaObjTargetCycleTargetReq=new BatchQueryEvaObjTargetCycleTargetReq();
  batchQueryEvaObjTargetCycleTargetReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2038966_1_73853
if(queryPlanningDataExportRangeListComRespDto!= null&&  queryPlanningDataExportRangeListComRespDto.getPlanningExportDetailList() !=null&& !CollectionUtil.isEmpty(queryPlanningDataExportRangeListComRespDto.getPlanningExportDetailList())){
      batchQueryEvaObjTargetCycleTargetReq.setEvaObjTargetCycleTargetList(queryPlanningDataExportRangeListComRespDto.getPlanningExportDetailList().stream().map(item->item.getEvaObjTargetCycleId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:2038965_1_73853
    }
if(reqDto!=null){
      batchQueryEvaObjTargetCycleTargetReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2038970_1_73853
    }

    /*3-3-09-01批量查被评对象目标周期目标列表[2255]   */
    Assert.isNull(batchQueryEvaObjTargetCycleTargetReq.getSubjectLifeCycle(),"D3查询规划数据导出内容明细列表(公共)-3-3-09-01批量查被评对象目标周期目标列表-主体生命周期不能为空",false);
Assert.isNull(batchQueryEvaObjTargetCycleTargetReq.getEvaluationTemplateId(),"D3查询规划数据导出内容明细列表(公共)-3-3-09-01批量查被评对象目标周期目标列表-冗余评价模板ID不能为空",false);
      listOmsEvaObjTargetCycleOset = mOmsEvaObjTargetCycleOsetService.batchQueryEvaObjTargetCycleTarget(batchQueryEvaObjTargetCycleTargetReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsEvaObjTargetCycleOset_1 = listOmsEvaObjTargetCycleOset;
           }
QueryHighMidBaseWorkCycleDataListComRespDto queryHighMidBaseWorkCycleDataListComRespDto = null;
    if(queryPlanningDataExportRangeListComRespDto !=null){
          QueryHighMidBaseWorkCycleDataListComReqDto queryHighMidBaseWorkCycleDataListComReqDto=new QueryHighMidBaseWorkCycleDataListComReqDto();
  queryHighMidBaseWorkCycleDataListComReqDto.setIsNewData("TRUE");//sourceId:2038977_1_73854
queryHighMidBaseWorkCycleDataListComReqDto.setDataUsageSceneCode("TARGET_PLAN_CALC_DATA_STATISTICS");//sourceId:2038979_1_73854
if(queryPlanningDataExportRangeListComRespDto!= null&&  queryPlanningDataExportRangeListComRespDto.getPlanningExportDetailList() !=null&& !CollectionUtil.isEmpty(queryPlanningDataExportRangeListComRespDto.getPlanningExportDetailList())){
      queryHighMidBaseWorkCycleDataListComReqDto.setEvaObjTargetCycleList(queryPlanningDataExportRangeListComRespDto.getPlanningExportDetailList().stream().map(item->item.getEvaObjTargetCycleId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:2038971_1_73854
    }
if(queryPlanningDataExportRangeListComRespDto!=null){
      queryHighMidBaseWorkCycleDataListComReqDto.setCycleId(queryPlanningDataExportRangeListComRespDto.getPeriodId());//SimpleFieldAssign//sourceId:2038972_1_73854
    }
if(reqDto!=null){
      queryHighMidBaseWorkCycleDataListComReqDto.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:2038973_1_73854
queryHighMidBaseWorkCycleDataListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2038974_1_73854
    }

    /*D4-查询高中基工作周期使用标准数据列表(公共)[6043]   */
    Assert.isNull(queryHighMidBaseWorkCycleDataListComReqDto.getParentSubMidCycleType(),"D3查询规划数据导出内容明细列表(公共)-D4-查询高中基工作周期使用标准数据列表(公共)-父子中周期类型不能为空",false);
Assert.isNull(queryHighMidBaseWorkCycleDataListComReqDto.getIsNewData(),"D3查询规划数据导出内容明细列表(公共)-D4-查询高中基工作周期使用标准数据列表(公共)-是否归属周期最新数据不能为空",false);
Assert.isNull(queryHighMidBaseWorkCycleDataListComReqDto.getDataUsageSceneCode(),"D3查询规划数据导出内容明细列表(公共)-D4-查询高中基工作周期使用标准数据列表(公共)-数据业务场景不能为空",false);
Assert.isNull(queryHighMidBaseWorkCycleDataListComReqDto.getEvaluationTemplateId(),"D3查询规划数据导出内容明细列表(公共)-D4-查询高中基工作周期使用标准数据列表(公共)-冗余评价模板ID不能为空",false);
      queryHighMidBaseWorkCycleDataListComRespDto = fwCalcStandardDataClient.queryHighMidBaseWorkCycleDataListCom(queryHighMidBaseWorkCycleDataListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      queryHighMidBaseWorkCycleDataListComRespDto_1 = queryHighMidBaseWorkCycleDataListComRespDto;
           }
      }
QueryPlanningDataExportDetailListComRespDto retData = new QueryPlanningDataExportDetailListComRespDto();
  //数据集融合  MoreListToOneSource
        if(queryPlanningDataExportRangeListComRespDto_1!= null && !CollectionUtil.isEmpty(queryPlanningDataExportRangeListComRespDto_1.getPlanningExportDetailList()) ){
          for (PlanningExportDetailDto planningExportDetailDto : queryPlanningDataExportRangeListComRespDto_1.getPlanningExportDetailList()) {
              PlanningExportDetailDto retElm = new PlanningExportDetailDto();
             if(queryPlanningDataExportRangeListComRespDto_1!=null){
      retElm.setEvaluationTempName(planningExportDetailDto.getEvaluationTempName());//SimpleFieldAssign//sourceId:431402_2
retElm.setRootTargetCategoryName(planningExportDetailDto.getRootTargetCategoryName());//SimpleFieldAssign//sourceId:431403_2
retElm.setLastTargetCategoryName(planningExportDetailDto.getLastTargetCategoryName());//SimpleFieldAssign//sourceId:431404_2
retElm.setObjectiveShortName(planningExportDetailDto.getObjectiveShortName());//SimpleFieldAssign//sourceId:431405_2
    }
              retData.getPlanningExportDetailList().add(retElm);
               if(batchQueryDeptComRespDto_1!= null){
          for (DeptDto deptDto : batchQueryDeptComRespDto_1.getDeptList()) {
                if (deptDto.getDeptId().equals(planningExportDetailDto.getDeptId())) {
                 if(batchQueryDeptComRespDto_1!=null){
      retElm.setDeptShortName(deptDto.getDeptShortName());//SimpleFieldAssign//sourceId:431409_2
    }
                }
            }
          }

 if(batchQueryInductionRecordListComRespDto_1!= null){
          for (PerOrgInductionRecordDto perOrgInductionRecordDto : batchQueryInductionRecordListComRespDto_1.getPerOrgInductionRecordList()) {
                if (perOrgInductionRecordDto.getInductionRecordId().equals(planningExportDetailDto.getPersonLiableInductionRecordId())) {
                 if(batchQueryInductionRecordListComRespDto_1!=null){
      retElm.setPersonLiableIdCardName(perOrgInductionRecordDto.getIdCardName());//SimpleFieldAssign//sourceId:431410_2
    }
                }
            }
          }

 if(batchQueryInductionRecordListComRespDto_3!= null){
          for (PerOrgInductionRecordDto perOrgInductionRecordDto : batchQueryInductionRecordListComRespDto_3.getPerOrgInductionRecordList()) {
                if (perOrgInductionRecordDto.getInductionRecordId().equals(planningExportDetailDto.getDirectorInductionRecordId())) {
                 if(batchQueryInductionRecordListComRespDto_3!=null){
      retElm.setDirectorIdCardName(perOrgInductionRecordDto.getIdCardName());//SimpleFieldAssign//sourceId:431411_2
    }
                }
            }
          }

 if(listOmsEvaObjTargetCycleOset_1!= null&& !CollectionUtil.isEmpty(listOmsEvaObjTargetCycleOset_1)){
          for (OmsEvaObjTargetCycleOset omsEvaObjTargetCycleOset : listOmsEvaObjTargetCycleOset_1) {
                if (omsEvaObjTargetCycleOset.getEvaObjTargetCycleId().equals(planningExportDetailDto.getEvaObjTargetCycleId())) {
                 retElm.setShowTargetValue(omsEvaObjTargetCycleOset.getShowTargetValue());//SimpleFieldAssign//sourceId:431563_2
retElm.setUnit(omsEvaObjTargetCycleOset.getUnit());//SimpleFieldAssign//sourceId:431564_2
                }
            }
          }

 if(queryHighMidBaseWorkCycleDataListComRespDto_1!= null){
          for (StandardDataDto standardDataDto : queryHighMidBaseWorkCycleDataListComRespDto_1.getStandardDataList()) {
                if (standardDataDto.getEntityId().equals(planningExportDetailDto.getEvaObjTargetCycleId())) {
                 if(queryHighMidBaseWorkCycleDataListComRespDto_1!=null){
      retElm.setActualValue(standardDataDto.getActualValue());//SimpleFieldAssign//sourceId:431565_2
retElm.setActualValueUnit(standardDataDto.getActualValueUnit());//SimpleFieldAssign//sourceId:431566_2
retElm.setProgressValue(standardDataDto.getProgressValue());//SimpleFieldAssign//sourceId:431567_2
retElm.setProgressValueUnit(standardDataDto.getProgressValueUnit());//SimpleFieldAssign//sourceId:431568_2
    }
                }
            }
          }

          }
        }//sourceId:2038917_1




return retData;
  }
/**
   * D3分析目标内容生命周期(公共)[10521]
   * gen by moon at 4/7/2025, 10:57:30 PM
   */
  @Trace(operationName = "D3分析目标内容生命周期(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AnalysisTargetContentSubjectLifeComRespDto analysisTargetContentSubjectLifeCom(AnalysisTargetContentSubjectLifeComReqDto reqDto){


      ImplementElevenReceivingFieldRespDto receptionServiceRes_1 =null;
if((reqDto!= null&&  reqDto.getTableTypeCode() !=null && reqDto.getTableTypeCode().equals("OMS_TARGET_OBJECTIVE"))) {
        //if(D3分析目标内容生命周期(公共).内容表类型编码 等于 指标表)  74014

OmsTargetObjective omsTargetObjective = null;
    QueryTargetObjectiveDetailReq queryTargetObjectiveDetailReq=new QueryTargetObjectiveDetailReq();
  queryTargetObjectiveDetailReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2044974_1_74016
if(reqDto!=null){
      queryTargetObjectiveDetailReq.setObjectiveId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:2044973_1_74016
    }

    /*3-3-03查询指标详情[9411]   */
    Assert.isNull(queryTargetObjectiveDetailReq.getObjectiveId(),"D3分析目标内容生命周期(公共)-3-3-03查询指标详情-指标ID不能为空",false);
Assert.isNull(queryTargetObjectiveDetailReq.getSpaceId(),"D3分析目标内容生命周期(公共)-3-3-03查询指标详情-创建于空间ID不能为空",false);
      omsTargetObjective = mOmsTargetObjectiveService.queryTargetObjectiveDetail(queryTargetObjectiveDetailReq)/*vcase invoke 本地 method 方法调用;*/;



//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes = null;
    if(omsTargetObjective !=null){
          ImplementElevenReceivingFieldReqDto receptionServiceReq=new ImplementElevenReceivingFieldReqDto();
  if(omsTargetObjective!=null){
      receptionServiceReq.setSubjectLifeCycle(omsTargetObjective.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:2045434_1_74018
    }

    /*M3接收出参字段：主体生命周期[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getSubjectLifeCycle(),"D3分析目标内容生命周期(公共)-M3接收出参字段：主体生命周期-主体生命周期不能为空",false);
      receptionServiceRes = nbTargetContCom.implementElevenReceivingField(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
           }
      }
else if((reqDto!= null&&  reqDto.getTableTypeCode() !=null && reqDto.getTableTypeCode().equals("OMS_TARGET_CATEGORY"))){
       //elseif(D3分析目标内容生命周期(公共).内容表类型编码 等于 目标分类表)  74015

OmsTargetCategory omsTargetCategory = null;
    QueryTargetCatDetailReq queryTargetCatDetailReq=new QueryTargetCatDetailReq();
  if(reqDto!=null){
      queryTargetCatDetailReq.setTargetCategoryId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:2044976_1_74017
    }

    /*3-3-02查目标分类详情[2595]   */
    Assert.isNull(queryTargetCatDetailReq.getTargetCategoryId(),"D3分析目标内容生命周期(公共)-3-3-02查目标分类详情-目标分类ID不能为空",false);
      omsTargetCategory = mOmsTargetCategoryService.queryTargetCatDetail(queryTargetCatDetailReq)/*vcase invoke 本地 method 方法调用;*/;



//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_2 = null;
    if(omsTargetCategory !=null){
          ImplementElevenReceivingFieldReqDto receptionServiceReq_1=new ImplementElevenReceivingFieldReqDto();
  if(omsTargetCategory!=null){
      receptionServiceReq_1.setSubjectLifeCycle(omsTargetCategory.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:2045434_1_74019
    }

    /*M3接收出参字段：主体生命周期[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getSubjectLifeCycle(),"D3分析目标内容生命周期(公共)-M3接收出参字段：主体生命周期-主体生命周期不能为空",false);
      receptionServiceRes_2 = nbTargetContCom.implementElevenReceivingField(receptionServiceReq_1);


      receptionServiceRes_1 = receptionServiceRes_2;
           }
    }
else if((reqDto!= null&&  reqDto.getTableTypeCode() !=null && reqDto.getTableTypeCode().equals("OMS_TARGET"))){
       //elseif(D3分析目标内容生命周期(公共).内容表类型编码 等于 目标表)  74020

OmsTarget omsTarget = null;
    QueryTargetDetailReq queryTargetDetailReq=new QueryTargetDetailReq();
  if(reqDto!=null){
      queryTargetDetailReq.setTargetId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:2045459_1_74021
    }

    /*3-3-01查目标详情[2488]   */
    Assert.isNull(queryTargetDetailReq.getTargetId(),"D3分析目标内容生命周期(公共)-3-3-01查目标详情-目标ID不能为空",false);
      omsTarget = mOmsTargetService.queryTargetDetail(queryTargetDetailReq)/*vcase invoke 本地 method 方法调用;*/;



//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_3 = null;
    if(omsTarget !=null){
          ImplementElevenReceivingFieldReqDto receptionServiceReq_2=new ImplementElevenReceivingFieldReqDto();
  if(omsTarget!=null){
      receptionServiceReq_2.setSubjectLifeCycle(omsTarget.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:2045434_1_74022
    }

    /*M3接收出参字段：主体生命周期[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getSubjectLifeCycle(),"D3分析目标内容生命周期(公共)-M3接收出参字段：主体生命周期-主体生命周期不能为空",false);
      receptionServiceRes_3 = nbTargetContCom.implementElevenReceivingField(receptionServiceReq_2);


      receptionServiceRes_1 = receptionServiceRes_3;
           }
    }
AnalysisTargetContentSubjectLifeComRespDto retData = new AnalysisTargetContentSubjectLifeComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setSubjectLifeCycle(receptionServiceRes_1.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:2045462_1
    }




return retData;
  }
///**
//   * D3查询指标详情(公共)[9412]
//   * gen by moon at 4/19/2024, 11:00:29 PM
//   */
//  @Trace(operationName = "D3查询指标详情(公共)")
//  @Tags({@Tag(key = "参数",value = "arg[0]"),
//            @Tag(key = "返回值",value = "returnedObj")})
//  @Transactional(rollbackFor=Exception.class)
//  @Override
//  public QueryTargetObjectiveDetailComRespDto queryTargetObjectiveDetailCom(QueryTargetObjectiveDetailComReqDto reqDto){
//
//
//      OmsTargetObjective omsTargetObjective_1 =null;
////步骤0: 3-3-03查询指标详情 - queryTargetObjectiveDetail
//     OmsTargetObjective omsTargetObjective = null;
//    QueryTargetObjectiveDetailReq queryTargetObjectiveDetailReq=new QueryTargetObjectiveDetailReq();
//  if(reqDto!=null){
//      queryTargetObjectiveDetailReq.setObjectiveId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:1737920_1
//queryTargetObjectiveDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1737921_1
//queryTargetObjectiveDetailReq.setIsArchive(reqDto.getIsArchive());//SimpleFieldAssign//sourceId:1737922_1
//queryTargetObjectiveDetailReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1737923_1
//    }
//
//    /*3-3-03查询指标详情[9411]   */
//    Assert.isNull(queryTargetObjectiveDetailReq.getEvaluationTemplateId(),"D3查询指标详情(公共)-3-3-03查询指标详情-冗余评价模板ID不能为空",false);
//      omsTargetObjective = mOmsTargetObjectiveService.queryTargetObjectiveDetail(queryTargetObjectiveDetailReq)/*vcase invoke 本地 method 方法调用;*/;
//
//
//      omsTargetObjective_1 = omsTargetObjective;
//
//QueryTargetObjectiveDetailComRespDto retData = new QueryTargetObjectiveDetailComRespDto();
//  if(omsTargetObjective_1!=null){
//      retData.setObjectiveId(omsTargetObjective_1.getObjectiveId());//SimpleFieldAssign//sourceId:1737933_1
//retData.setTargetValueType(omsTargetObjective_1.getTargetValueType());//SimpleFieldAssign//sourceId:1737934_1
//retData.setIsLeft(omsTargetObjective_1.getIsLeft());//SimpleFieldAssign//sourceId:1737935_1
//retData.setUnit(omsTargetObjective_1.getUnit());//SimpleFieldAssign//sourceId:1737936_1
//retData.setDigitalUnit(omsTargetObjective_1.getDigitalUnit());//SimpleFieldAssign//sourceId:1737937_1
//    }
//
//
//
//
//return retData;
//  }
  //
}
